@umituz/react-native-exception 1.2.0 → 1.2.2

package/LICENSE

@@ -34,3 +34,8 @@ SOFTWARE.
 
 
 
+
+
+
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-exception",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Exception handling and error tracking for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -32,10 +32,11 @@
     "react": ">=18.2.0",
     "react-native": ">=0.74.0",
     "zustand": "^5.0.2",
-    "uuid": "^9.0.0",
+    "uuid": "^10.0.0",
     "react-native-get-random-values": "^1.11.0",
     "@umituz/react-native-design-system-theme": "*",
-    "@umituz/react-native-design-system": "*"
+    "@umituz/react-native-design-system": "*",
+    "lucide-react-native": "^0.468.0"
   },
   "peerDependenciesMeta": {
     "@umituz/react-native-design-system-theme": {
@@ -43,6 +44,7 @@
     }
   },
   "devDependencies": {
+    "@types/uuid": "^10.0.0",
     "typescript": "^5.3.3",
     "@types/react": "^18.2.45",
     "@types/react-native": "^0.73.0",

package/src/domain/entities/ExceptionEntity.ts

@@ -20,7 +20,7 @@ export interface ExceptionContext {
 export interface ExceptionEntity {
   id: string;
   message: string;
-  stack?: string;
+  stackTrace?: string;
   severity: ExceptionSeverity;
   category: ExceptionCategory;
   context: ExceptionContext;
@@ -34,7 +34,7 @@ export interface ErrorLog {
   exceptionId: string;
   userId?: string;
   message: string;
-  stack?: string;
+  stackTrace?: string;
   severity: ExceptionSeverity;
   category: ExceptionCategory;
   context: ExceptionContext;
@@ -53,7 +53,7 @@ export function createException(
   return {
     id: uuidv4(),
     message: error.message,
-    stack: error.stack,
+    stackTrace: error.stack,
     severity,
     category,
     context,
@@ -74,7 +74,7 @@ export function createErrorLog(
     exceptionId: exception.id,
     userId: exception.context.userId,
     message: exception.message,
-    stack: exception.stack,
+    stackTrace: exception.stackTrace,
     severity: exception.severity,
     category: exception.category,
     context: exception.context,

package/src/domain/repositories/IExceptionRepository.ts

@@ -58,3 +58,8 @@ export interface IExceptionRepository {
 
 
 
+
+
+
+
+

package/src/index.ts

@@ -40,7 +40,11 @@ export type {
 export { useExceptionStore, useExceptions } from './infrastructure/storage/ExceptionStore';
 
 // Services
-export { ExceptionService, exceptionService } from './infrastructure/services/ExceptionService';
+// Infrastructure Services
+export { ExceptionService } from './infrastructure/services/ExceptionService';
+export { ExceptionHandler } from './infrastructure/services/ExceptionHandler';
+export { ExceptionReporter } from './infrastructure/services/ExceptionReporter';
+export { ExceptionLogger } from './infrastructure/services/ExceptionLogger';
 
 // =============================================================================
 // PRESENTATION LAYER EXPORTS

package/src/infrastructure/services/ExceptionHandler.ts

@@ -0,0 +1,93 @@
+/**
+ * Exception Handler Service
+ *
+ * Handles exception creation, validation, and basic processing.
+ *
+ * SOLID: Single Responsibility - Only exception handling
+ * DRY: Centralized exception processing logic
+ * KISS: Simple exception handling interface
+ */
+
+import type {
+  ExceptionEntity,
+  ExceptionContext,
+  ExceptionSeverity,
+  ExceptionCategory,
+} from '../../domain/entities/ExceptionEntity';
+import {
+  createException,
+  shouldReportException,
+} from '../../domain/entities/ExceptionEntity';
+
+export class ExceptionHandler {
+  /**
+   * Create and validate an exception
+   */
+  static createException(
+    error: Error,
+    severity: ExceptionSeverity = 'error',
+    category: ExceptionCategory = 'unknown',
+    context: ExceptionContext = {},
+  ): ExceptionEntity {
+    return createException(error, severity, category, context);
+  }
+
+  /**
+   * Check if exception should be reported
+   */
+  static shouldReportException(exception: ExceptionEntity): boolean {
+    return shouldReportException(exception);
+  }
+
+  /**
+   * Validate exception data
+   */
+  static validateException(exception: ExceptionEntity): boolean {
+    return !!(
+      exception.id &&
+      exception.message &&
+      exception.timestamp &&
+      exception.severity &&
+      exception.category
+    );
+  }
+
+  /**
+   * Sanitize exception for logging
+   */
+  static sanitizeException(exception: ExceptionEntity): ExceptionEntity {
+    return {
+      ...exception,
+      message: this.sanitizeMessage(exception.message),
+      context: this.sanitizeContext(exception.context),
+    };
+  }
+
+  /**
+   * Sanitize error message
+   */
+  private static sanitizeMessage(message: string): string {
+    // Remove sensitive information from error messages
+    return message
+      .replace(/password=[^&\s]*/gi, 'password=***')
+      .replace(/token=[^&\s]*/gi, 'token=***')
+      .replace(/key=[^&\s]*/gi, 'key=***');
+  }
+
+  /**
+   * Sanitize context object
+   */
+  private static sanitizeContext(context: ExceptionContext): ExceptionContext {
+    const sanitized: ExceptionContext = { ...context };
+
+    // Remove sensitive fields
+    const sensitiveFields = ['password', 'token', 'apiKey', 'secret'];
+    sensitiveFields.forEach(field => {
+      if (sanitized[field as keyof ExceptionContext]) {
+        (sanitized as any)[field] = '***';
+      }
+    });
+
+    return sanitized;
+  }
+}

package/src/infrastructure/services/ExceptionLogger.ts

@@ -0,0 +1,157 @@
+/**
+ * Exception Logger Service
+ *
+ * Handles local logging and persistence of exceptions.
+ *
+ * SOLID: Single Responsibility - Only exception logging/persistence
+ * DRY: Centralized logging logic
+ * KISS: Simple logging interface
+ */
+
+import type { ExceptionEntity } from '../../domain/entities/ExceptionEntity';
+import { ExceptionHandler } from './ExceptionHandler';
+
+export class ExceptionLogger {
+  private static readonly STORAGE_KEY = '@exceptions';
+  private maxStoredExceptions = 100;
+
+  /**
+   * Log exception locally
+   */
+  async logException(exception: ExceptionEntity): Promise<void> {
+    try {
+      const sanitizedException = ExceptionHandler.sanitizeException(exception);
+      const existingExceptions = await this.getStoredExceptions();
+
+      // Add new exception
+      existingExceptions.unshift(sanitizedException);
+
+      // Limit storage size
+      if (existingExceptions.length > this.maxStoredExceptions) {
+        existingExceptions.splice(this.maxStoredExceptions);
+      }
+
+      await this.setStorageItem(ExceptionLogger.STORAGE_KEY, JSON.stringify(existingExceptions));
+    } catch (error) {
+      // Fallback to console if storage fails
+      console.error('Failed to log exception:', error);
+    }
+  }
+
+  /**
+   * Get stored exceptions
+   */
+  async getStoredExceptions(): Promise<ExceptionEntity[]> {
+    try {
+      const stored = await this.getStorageItem(ExceptionLogger.STORAGE_KEY);
+      return stored ? JSON.parse(stored) : [];
+    } catch (error) {
+      console.warn('Failed to get stored exceptions:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Clear all stored exceptions
+   */
+  async clearStoredExceptions(): Promise<void> {
+    try {
+      await this.setStorageItem(ExceptionLogger.STORAGE_KEY, JSON.stringify([]));
+    } catch (error) {
+      console.warn('Failed to clear stored exceptions:', error);
+    }
+  }
+
+  /**
+   * Get exceptions by category
+   */
+  async getExceptionsByCategory(category: ExceptionEntity['category']): Promise<ExceptionEntity[]> {
+    const exceptions = await this.getStoredExceptions();
+    return exceptions.filter(ex => ex.category === category);
+  }
+
+  /**
+   * Get exceptions by severity
+   */
+  async getExceptionsBySeverity(severity: ExceptionEntity['severity']): Promise<ExceptionEntity[]> {
+    const exceptions = await this.getStoredExceptions();
+    return exceptions.filter(ex => ex.severity === severity);
+  }
+
+  /**
+   * Get recent exceptions (last N days)
+   */
+  async getRecentExceptions(days: number = 7): Promise<ExceptionEntity[]> {
+    const exceptions = await this.getStoredExceptions();
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - days);
+
+    return exceptions.filter(ex => new Date(ex.timestamp) >= cutoffDate);
+  }
+
+  /**
+   * Get exception statistics
+   */
+  async getExceptionStats(): Promise<{
+    total: number;
+    bySeverity: Record<ExceptionEntity['severity'], number>;
+    byCategory: Record<ExceptionEntity['category'], number>;
+  }> {
+    const exceptions = await this.getStoredExceptions();
+
+    const bySeverity: Record<ExceptionEntity['severity'], number> = {
+      fatal: 0,
+      error: 0,
+      warning: 0,
+      info: 0,
+    };
+
+    const byCategory: Record<ExceptionEntity['category'], number> = {
+      network: 0,
+      validation: 0,
+      authentication: 0,
+      authorization: 0,
+      'business-logic': 0,
+      system: 0,
+      storage: 0,
+      unknown: 0,
+    };
+
+    exceptions.forEach(ex => {
+      bySeverity[ex.severity]++;
+      byCategory[ex.category]++;
+    });
+
+    return {
+      total: exceptions.length,
+      bySeverity,
+      byCategory,
+    };
+  }
+
+  /**
+   * Update max stored exceptions limit
+   */
+  setMaxStoredExceptions(limit: number): void {
+    this.maxStoredExceptions = Math.max(1, limit);
+  }
+
+  /**
+   * Storage abstraction (can be overridden for different storage backends)
+   */
+  protected async getStorageItem(key: string): Promise<string | null> {
+    // Default implementation using localStorage/globalThis for web, AsyncStorage for RN
+    if (typeof globalThis !== 'undefined' && globalThis.localStorage) {
+      return globalThis.localStorage.getItem(key);
+    }
+    // For React Native, this would be overridden
+    return null;
+  }
+
+  protected async setStorageItem(key: string, value: string): Promise<void> {
+    if (typeof globalThis !== 'undefined' && globalThis.localStorage) {
+      globalThis.localStorage.setItem(key, value);
+    }
+    // For React Native, this would be overridden
+  }
+}

package/src/infrastructure/services/ExceptionReporter.ts

@@ -0,0 +1,124 @@
+/**
+ * Exception Reporter Service
+ *
+ * Handles reporting exceptions to external services.
+ *
+ * SOLID: Single Responsibility - Only exception reporting
+ * DRY: Centralized reporting logic
+ * KISS: Simple reporting interface
+ */
+
+import type { ExceptionEntity } from '../../domain/entities/ExceptionEntity';
+
+export interface ExceptionReporterConfig {
+  enabled: boolean;
+  endpoint?: string;
+  apiKey?: string;
+  environment: 'development' | 'staging' | 'production';
+}
+
+export class ExceptionReporter {
+  private config: ExceptionReporterConfig;
+
+  constructor(config: ExceptionReporterConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Report exception to external service
+   */
+  async reportException(exception: ExceptionEntity): Promise<boolean> {
+    if (!this.config.enabled) {
+      return false;
+    }
+
+    try {
+      // Default console reporting for development
+      if (this.config.environment === 'development') {
+        return this.reportToConsole(exception);
+      }
+
+      // External service reporting
+      if (this.config.endpoint) {
+        return await this.reportToExternalService(exception);
+      }
+
+      return false;
+    } catch (error) {
+      // Don't throw in reporter to avoid infinite loops
+      console.warn('Exception reporting failed:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Report to console (development)
+   */
+  private reportToConsole(exception: ExceptionEntity): boolean {
+    const level = this.getConsoleLevel(exception.severity);
+
+    console[level](
+      `[${exception.severity.toUpperCase()}] ${exception.category}:`,
+      exception.message,
+      {
+        id: exception.id,
+        timestamp: exception.timestamp,
+        context: exception.context,
+        stack: exception.stackTrace,
+      }
+    );
+
+    return true;
+  }
+
+  /**
+   * Report to external service
+   */
+  private async reportToExternalService(exception: ExceptionEntity): Promise<boolean> {
+    if (!this.config.endpoint) {
+      return false;
+    }
+
+    const response = await fetch(this.config.endpoint, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(this.config.apiKey && { 'Authorization': `Bearer ${this.config.apiKey}` }),
+      },
+      body: JSON.stringify({
+        id: exception.id,
+        message: exception.message,
+        severity: exception.severity,
+        category: exception.category,
+        timestamp: exception.timestamp,
+        context: exception.context,
+        stackTrace: exception.stackTrace,
+        environment: this.config.environment,
+      }),
+    });
+
+    return response.ok;
+  }
+
+  /**
+   * Get console level for severity
+   */
+  private getConsoleLevel(severity: ExceptionEntity['severity']): 'log' | 'warn' | 'error' {
+    switch (severity) {
+      case 'fatal':
+      case 'error':
+        return 'error';
+      case 'warning':
+        return 'warn';
+      default:
+        return 'log';
+    }
+  }
+
+  /**
+   * Update reporter configuration
+   */
+  updateConfig(config: Partial<ExceptionReporterConfig>): void {
+    this.config = { ...this.config, ...config };
+  }
+}

package/src/infrastructure/services/ExceptionService.ts

@@ -1,6 +1,12 @@
 /**
  * Exception Service - Infrastructure Layer
- * Centralized exception handling and reporting
+ *
+ * Facade for exception handling using composition.
+ * Delegates to specialized services for specific operations.
+ *
+ * SOLID: Facade pattern - Single entry point, delegates to specialists
+ * DRY: Avoids code duplication by composing smaller services
+ * KISS: Simple interface, complex operations delegated
  */
 
 import type {
@@ -9,41 +15,45 @@ import type {
   ExceptionSeverity,
   ExceptionCategory,
 } from '../../domain/entities/ExceptionEntity';
-import {
-  createException,
-  shouldReportException,
-} from '../../domain/entities/ExceptionEntity';
+import { ExceptionHandler } from './ExceptionHandler';
+import { ExceptionReporter } from './ExceptionReporter';
+import { ExceptionLogger } from './ExceptionLogger';
 import { useExceptionStore } from '../storage/ExceptionStore';
 
 export class ExceptionService {
-  private static instance: ExceptionService;
-
-  private constructor() {}
-
-  static getInstance(): ExceptionService {
-    if (!ExceptionService.instance) {
-      ExceptionService.instance = new ExceptionService();
-    }
-    return ExceptionService.instance;
+  private logger: ExceptionLogger;
+  private reporter: ExceptionReporter;
+
+  constructor(reporterConfig?: ExceptionReporter['config']) {
+    this.logger = new ExceptionLogger();
+    this.reporter = new ExceptionReporter(
+      reporterConfig || {
+        enabled: false,
+        environment: 'development'
+      }
+    );
   }
 
   /**
    * Handle an exception
    */
-  handleException(
+  async handleException(
     error: Error,
     severity: ExceptionSeverity = 'error',
     category: ExceptionCategory = 'unknown',
     context: ExceptionContext = {},
-  ): void {
-    const exception = createException(error, severity, category, context);
+  ): Promise<void> {
+    const exception = ExceptionHandler.createException(error, severity, category, context);
 
     // Add to store
     useExceptionStore.getState().addException(exception);
 
+    // Log locally
+    await this.logger.logException(exception);
+
     // Report to external service if needed
-    if (shouldReportException(exception)) {
-      this.reportException(exception);
+    if (ExceptionHandler.shouldReportException(exception)) {
+      await this.reporter.reportException(exception);
     }
 
     // Mark as handled
@@ -51,29 +61,66 @@ export class ExceptionService {
   }
 
   /**
-   * Report exception to external service (e.g., Sentry)
+   * Handle network errors
    */
-  private async reportException(exception: ExceptionEntity): Promise<void> {
-    try {
-      // Mark as reported
-      useExceptionStore.getState().markAsReported(exception.id);
-    } catch (error) {
-      // Silent failure
-    }
+  async handleNetworkError(error: Error, context: ExceptionContext = {}): Promise<void> {
+    await this.handleException(error, 'error', 'network', context);
   }
 
   /**
-   * Handle network errors
+   * Handle validation errors
    */
-  handleNetworkError(error: Error, context: ExceptionContext = {}): void {
-    this.handleException(error, 'error', 'network', context);
+  async handleValidationError(error: Error, context: ExceptionContext = {}): Promise<void> {
+    await this.handleException(error, 'warning', 'validation', context);
   }
 
   /**
-   * Handle validation errors
+   * Handle authentication errors
    */
-  handleValidationError(error: Error, context: ExceptionContext = {}): void {
-    this.handleException(error, 'warning', 'validation', context);
+  async handleAuthError(error: Error, context: ExceptionContext = {}): Promise<void> {
+    await this.handleException(error, 'error', 'authentication', context);
+  }
+
+  /**
+   * Handle system errors
+   */
+  async handleSystemError(error: Error, context: ExceptionContext = {}): Promise<void> {
+    await this.handleException(error, 'fatal', 'system', context);
+  }
+
+  /**
+   * Get stored exceptions
+   */
+  async getStoredExceptions(): Promise<ExceptionEntity[]> {
+    return this.logger.getStoredExceptions();
+  }
+
+  /**
+   * Get exception statistics
+   */
+  async getExceptionStats() {
+    return this.logger.getExceptionStats();
+  }
+
+  /**
+   * Clear stored exceptions
+   */
+  async clearStoredExceptions(): Promise<void> {
+    await this.logger.clearStoredExceptions();
+  }
+
+  /**
+   * Update reporter configuration
+   */
+  updateReporterConfig(config: Partial<ExceptionReporter['config']>): void {
+    this.reporter.updateConfig(config);
+  }
+
+  /**
+   * Set max stored exceptions
+   */
+  setMaxStoredExceptions(limit: number): void {
+    this.logger.setMaxStoredExceptions(limit);
   }
 
   /**
@@ -98,7 +145,13 @@ export class ExceptionService {
   }
 }
 
-export const exceptionService = ExceptionService.getInstance();
+// Export for backward compatibility - create default instance
+export const exceptionService = new ExceptionService();
+
+
+
+
+
 
 
 

package/src/infrastructure/storage/ExceptionStore.ts

@@ -107,3 +107,8 @@ export const useExceptions = () => {
 
 
 
+
+
+
+
+

package/src/presentation/components/EmptyState.tsx

@@ -7,12 +7,7 @@
 
 import React from "react";
 import { View, StyleSheet, TouchableOpacity } from "react-native";
-import {
-  useAppDesignTokens,
-  AtomicIcon,
-  AtomicText,
-  STATIC_TOKENS,
-} from "@umituz/react-native-design-system";
+import { AtomicIcon, AtomicText, useAppDesignTokens, STATIC_TOKENS } from "@umituz/react-native-design-system";
 
 export interface EmptyStateProps {
   icon?: string;

package/src/presentation/components/ErrorBoundary.tsx

@@ -6,7 +6,7 @@
 import React, { Component, ReactNode } from 'react';
 import { View, Text, StyleSheet, TouchableOpacity } from 'react-native';
 import { exceptionService } from '../../infrastructure/services/ExceptionService';
-import { useAppDesignTokens } from '@umituz/react-native-design-system-theme';
+import { useAppDesignTokens } from '@umituz/react-native-design-system';
 
 interface Props {
   children: ReactNode;