@umituz/react-native-design-system 2.6.107 → 2.6.111

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@umituz/react-native-design-system",
-  "version": "2.6.107",
-  "description": "Universal design system for React Native apps - Consolidated package with atoms, molecules, organisms, theme, typography, responsive and safe area utilities",
+  "version": "2.6.111",
+  "description": "Universal design system for React Native apps - Consolidated package with atoms, molecules, organisms, theme, typography, responsive, safe area, exception, infinite scroll and UUID utilities",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "exports": {

package/src/exception/domain/entities/ExceptionEntity.ts

@@ -0,0 +1,115 @@
+/**
+ * Exception Entity - Domain Layer
+ * Pure business logic representation of errors and exceptions
+ */
+
+import { generateUUID } from '@umituz/react-native-uuid';
+
+export type ExceptionSeverity = 'fatal' | 'error' | 'warning' | 'info';
+export type ExceptionCategory = 'network' | 'validation' | 'authentication' | 'authorization' | 'business-logic' | 'system' | 'storage' | 'unknown';
+
+export interface ExceptionContext {
+  userId?: string;
+  screen?: string;
+  action?: string;
+  componentStack?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ExceptionEntity {
+  id: string;
+  message: string;
+  stackTrace?: string;
+  severity: ExceptionSeverity;
+  category: ExceptionCategory;
+  context: ExceptionContext;
+  timestamp: Date;
+  handled: boolean;
+  reported: boolean;
+}
+
+export interface ErrorLog {
+  id: string;
+  exceptionId: string;
+  userId?: string;
+  message: string;
+  stackTrace?: string;
+  severity: ExceptionSeverity;
+  category: ExceptionCategory;
+  context: ExceptionContext;
+  createdAt: Date;
+}
+
+/**
+ * Factory function to create an exception entity
+ */
+export function createException(
+  error: Error,
+  severity: ExceptionSeverity = 'error',
+  category: ExceptionCategory = 'unknown',
+  context: ExceptionContext = {}
+): ExceptionEntity {
+  return {
+    id: generateUUID(),
+    message: error.message,
+    stackTrace: error.stack,
+    severity,
+    category,
+    context,
+    timestamp: new Date(),
+    handled: false,
+    reported: false,
+  };
+}
+
+/**
+ * Factory function to create an error log
+ */
+export function createErrorLog(
+  exception: ExceptionEntity
+): ErrorLog {
+  return {
+    id: generateUUID(),
+    exceptionId: exception.id,
+    userId: exception.context.userId,
+    message: exception.message,
+    stackTrace: exception.stackTrace,
+    severity: exception.severity,
+    category: exception.category,
+    context: exception.context,
+    createdAt: new Date(),
+  };
+}
+
+/**
+ * Determine if exception should be reported
+ */
+export function shouldReportException(exception: ExceptionEntity): boolean {
+  // Don't report warnings or info
+  if (exception.severity === 'warning' || exception.severity === 'info') {
+    return false;
+  }
+
+  // Don't report validation errors (user errors)
+  if (exception.category === 'validation') {
+    return false;
+  }
+
+  // Report everything else
+  return true;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/src/exception/domain/repositories/IExceptionRepository.ts

@@ -0,0 +1,37 @@
+/**
+ * Exception Repository Interface
+ * Defines the contract for exception data persistence
+ */
+
+import type { ExceptionEntity, ErrorLog } from '../entities/ExceptionEntity';
+
+export interface ExceptionRepositoryError {
+    code: string;
+    message: string;
+}
+
+export type ExceptionResult<T> =
+    | { success: true; data: T }
+    | { success: false; error: ExceptionRepositoryError };
+
+export interface IExceptionRepository {
+    /**
+     * Save an exception to storage
+     */
+    save(exception: ExceptionEntity): Promise<ExceptionResult<void>>;
+
+    /**
+     * Get all stored exceptions
+     */
+    getAll(): Promise<ExceptionResult<ExceptionEntity[]>>;
+
+    /**
+     * Clear all stored exceptions
+     */
+    clear(): Promise<ExceptionResult<void>>;
+
+    /**
+     * Log an error
+     */
+    log(errorLog: ErrorLog): Promise<ExceptionResult<void>>;
+}

package/src/exception/index.ts

@@ -0,0 +1,65 @@
+/**
+ * @umituz/react-native-exception - Public API
+ *
+ * Exception handling and error tracking for React Native apps
+ *
+ * Usage:
+ *   import { ErrorBoundary, exceptionService, useExceptionStore } from '@umituz/react-native-exception';
+ */
+
+// =============================================================================
+// DOMAIN LAYER EXPORTS
+// =============================================================================
+
+// Entities
+export type {
+  ExceptionEntity,
+  ErrorLog,
+  ExceptionContext,
+  ExceptionSeverity,
+  ExceptionCategory,
+} from './domain/entities/ExceptionEntity';
+export {
+  createException,
+  createErrorLog,
+  shouldReportException,
+} from './domain/entities/ExceptionEntity';
+
+// Repositories
+export type {
+  IExceptionRepository,
+  ExceptionRepositoryError,
+  ExceptionResult,
+} from './domain/repositories/IExceptionRepository';
+
+// =============================================================================
+// INFRASTRUCTURE LAYER EXPORTS
+// =============================================================================
+
+// State Store (Zustand)
+export { useExceptionStore, useExceptions } from './infrastructure/storage/ExceptionStore';
+
+// Services
+// 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
+// =============================================================================
+
+// Components
+export { ErrorBoundary } from './presentation/components/ErrorBoundary';
+export { ExceptionEmptyState } from './presentation/components/ExceptionEmptyState';
+export type { ExceptionEmptyStateProps } from './presentation/components/ExceptionEmptyState';
+export { ExceptionErrorState } from './presentation/components/ExceptionErrorState';
+export type { ExceptionErrorStateProps } from './presentation/components/ExceptionErrorState';
+
+
+
+
+
+
+

package/src/exception/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.metadata && sanitized.metadata[field]) {
+        sanitized.metadata = { ...sanitized.metadata, [field]: '***' };
+      }
+    });
+
+    return sanitized;
+  }
+}

package/src/exception/infrastructure/services/ExceptionLogger.ts

@@ -0,0 +1,142 @@
+/**
+ * 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';
+import { storageRepository } from '@umituz/react-native-storage';
+
+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 storageRepository.setString(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 result = await storageRepository.getString(ExceptionLogger.STORAGE_KEY, '[]');
+      if (result.success) {
+        return JSON.parse(result.data);
+      }
+      return [];
+    } catch (error) {
+      console.warn('Failed to get stored exceptions:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Clear all stored exceptions
+   */
+  async clearStoredExceptions(): Promise<void> {
+    try {
+      await storageRepository.setString(ExceptionLogger.STORAGE_KEY, '[]');
+    } 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);
+  }
+}

package/src/exception/infrastructure/services/ExceptionReporter.ts

@@ -0,0 +1,134 @@
+/**
+ * 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 };
+  }
+}
+
+
+
+
+
+
+
+
+
+