@umituz/react-native-auth 1.12.0 → 2.0.1

package/lib/presentation/screens/RegisterScreen.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useNavigation } from "@react-navigation/native";
+import { useLocalization } from "@umituz/react-native-localization";
+import { AuthContainer } from "../components/AuthContainer";
+import { AuthHeader } from "../components/AuthHeader";
+import { AuthFormCard } from "../components/AuthFormCard";
+import { RegisterForm } from "../components/RegisterForm";
+export const RegisterScreen = ({ termsUrl, privacyUrl, onTermsPress, onPrivacyPress, }) => {
+    const { t } = useLocalization();
+    const navigation = useNavigation();
+    const handleNavigateToLogin = () => {
+        navigation.navigate("Login");
+    };
+    return (_jsxs(AuthContainer, { children: [_jsx(AuthHeader, { title: t("auth.createAccount") }), _jsx(AuthFormCard, { children: _jsx(RegisterForm, { onNavigateToLogin: handleNavigateToLogin, termsUrl: termsUrl, privacyUrl: privacyUrl, onTermsPress: onTermsPress, onPrivacyPress: onPrivacyPress }) })] }));
+};

package/lib/presentation/utils/getAuthErrorMessage.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Get localized error message from AuthError
+ * Maps error codes to localization keys
+ */
+/**
+ * Map AuthError code to localization key
+ */
+export declare function getAuthErrorLocalizationKey(error: Error): string;

package/lib/presentation/utils/getAuthErrorMessage.js

@@ -0,0 +1,69 @@
+/**
+ * Get localized error message from AuthError
+ * Maps error codes to localization keys
+ */
+import { AuthError } from "../../domain/errors/AuthError";
+/**
+ * Map AuthError code to localization key
+ */
+export function getAuthErrorLocalizationKey(error) {
+    const code = error instanceof AuthError ? error.code : undefined;
+    // Map error codes to localization keys
+    const errorCodeMap = {
+        AUTH_INVALID_EMAIL: "auth.errors.invalidEmail",
+        AUTH_WEAK_PASSWORD: "auth.errors.weakPassword",
+        AUTH_USER_NOT_FOUND: "auth.errors.userNotFound",
+        AUTH_WRONG_PASSWORD: "auth.errors.wrongPassword",
+        AUTH_EMAIL_ALREADY_IN_USE: "auth.errors.emailAlreadyInUse",
+        AUTH_NETWORK_ERROR: "auth.errors.networkError",
+        AUTH_CONFIG_ERROR: "auth.errors.configurationError",
+        AUTH_TOO_MANY_REQUESTS: "auth.errors.tooManyRequests",
+        AUTH_USER_DISABLED: "auth.errors.userDisabled",
+        AUTH_NOT_INITIALIZED: "auth.errors.authNotInitialized",
+    };
+    // Check error name for specific error types
+    if (error.name === "AuthInvalidEmailError") {
+        return "auth.errors.invalidEmail";
+    }
+    if (error.name === "AuthWeakPasswordError") {
+        return "auth.errors.weakPassword";
+    }
+    if (error.name === "AuthUserNotFoundError") {
+        return "auth.errors.userNotFound";
+    }
+    if (error.name === "AuthWrongPasswordError") {
+        return "auth.errors.wrongPassword";
+    }
+    if (error.name === "AuthEmailAlreadyInUseError") {
+        return "auth.errors.emailAlreadyInUse";
+    }
+    if (error.name === "AuthNetworkError") {
+        return "auth.errors.networkError";
+    }
+    if (error.name === "AuthConfigurationError") {
+        return "auth.errors.configurationError";
+    }
+    if (error.name === "AuthInitializationError") {
+        return "auth.errors.authNotInitialized";
+    }
+    // Use code if available
+    if (code && errorCodeMap[code]) {
+        return errorCodeMap[code];
+    }
+    // Check error message for specific patterns
+    const message = error.message.toLowerCase();
+    if (message.includes("too many requests")) {
+        return "auth.errors.tooManyRequests";
+    }
+    if (message.includes("user account has been disabled") || message.includes("user disabled")) {
+        return "auth.errors.userDisabled";
+    }
+    if (message.includes("not properly configured") || message.includes("configuration")) {
+        return "auth.errors.configurationError";
+    }
+    if (message.includes("not enabled") || message.includes("operation not allowed")) {
+        return "auth.errors.operationNotAllowed";
+    }
+    // Default to unknown error
+    return "auth.errors.unknownError";
+}

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "1.12.0",
-  "description": "Authentication service for React Native apps - Secure, type-safe, and production-ready. Provider-agnostic design supports Firebase Auth and can be adapted for Supabase or other providers.",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "version": "2.0.1",
+  "description": "Authentication service for React Native apps - Secure, type-safe, and production-ready. Provider-agnostic design with dependency injection, configurable validation, and comprehensive error handling.",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
   "scripts": {
+    "build": "tsc",
     "typecheck": "tsc --noEmit",
     "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
     "version:patch": "npm version patch -m 'chore: release v%s'",
     "version:minor": "npm version minor -m 'chore: release v%s'",
     "version:major": "npm version major -m 'chore: release v%s'"
@@ -49,6 +54,8 @@
     "firebase": "^11.10.0",
     "@types/react": "^18.2.45",
     "@types/react-native": "^0.73.0",
+    "@types/jest": "^29.5.0",
+    "jest": "^29.5.0",
     "react": "^18.2.0",
     "react-native": "^0.74.0",
     "typescript": "^5.3.3"
@@ -57,6 +64,7 @@
     "access": "public"
   },
   "files": [
+    "lib",
     "src",
     "README.md",
     "LICENSE"

package/src/__tests__/services/AuthCoreService.test.ts

@@ -0,0 +1,247 @@
+/**
+ * AuthCoreService Tests
+ */
+
+import { AuthCoreService } from '../../../src/infrastructure/services/AuthCoreService';
+import { DEFAULT_AUTH_CONFIG } from '../../../src/domain/value-objects/AuthConfig';
+import type { IAuthProvider } from '../../../src/application/ports/IAuthProvider';
+import type { AuthUser } from '../../../src/domain/entities/AuthUser';
+
+describe('AuthCoreService', () => {
+  let authCoreService: AuthCoreService;
+  let mockProvider: jest.Mocked<IAuthProvider>;
+
+  beforeEach(() => {
+    mockProvider = {
+      initialize: jest.fn(),
+      isInitialized: jest.fn().mockReturnValue(true),
+      signIn: jest.fn(),
+      signUp: jest.fn(),
+      signOut: jest.fn(),
+      getCurrentUser: jest.fn(),
+      onAuthStateChange: jest.fn().mockReturnValue(jest.fn()),
+    };
+
+    authCoreService = new AuthCoreService(DEFAULT_AUTH_CONFIG);
+  });
+
+  describe('constructor', () => {
+    it('should initialize with provided config', () => {
+      const customConfig = {
+        ...DEFAULT_AUTH_CONFIG,
+        password: {
+          ...DEFAULT_AUTH_CONFIG.password,
+          minLength: 12,
+        },
+      };
+
+      const service = new AuthCoreService(customConfig);
+      expect(service.getConfig()).toEqual(customConfig);
+    });
+  });
+
+  describe('initialize', () => {
+    it('should initialize with IAuthProvider', async () => {
+      await authCoreService.initialize(mockProvider);
+      expect(mockProvider.initialize).toHaveBeenCalled();
+    });
+
+    it('should initialize with Firebase Auth instance', async () => {
+      const mockFirebaseAuth = {
+        currentUser: null,
+      } as any;
+
+      await expect(authCoreService.initialize(mockFirebaseAuth)).rejects.toThrow();
+    });
+
+    it('should throw error when no provider provided', async () => {
+      await expect(authCoreService.initialize(null as any)).rejects.toThrow(
+        'Auth provider or Firebase Auth instance is required'
+      );
+    });
+  });
+
+  describe('isInitialized', () => {
+    it('should return false when not initialized', () => {
+      expect(authCoreService.isInitialized()).toBe(false);
+    });
+
+    it('should return true when initialized', async () => {
+      await authCoreService.initialize(mockProvider);
+      expect(authCoreService.isInitialized()).toBe(true);
+    });
+  });
+
+  describe('signUp', () => {
+    const mockUser: AuthUser = {
+      uid: 'test-uid',
+      email: 'test@example.com',
+      displayName: 'Test User',
+      isAnonymous: false,
+      emailVerified: false,
+      photoURL: null,
+    };
+
+    beforeEach(async () => {
+      await authCoreService.initialize(mockProvider);
+    });
+
+    it('should sign up successfully with valid credentials', async () => {
+      mockProvider.signUp.mockResolvedValue(mockUser);
+
+      const result = await authCoreService.signUp({
+        email: 'test@example.com',
+        password: 'password123',
+        displayName: 'Test User',
+      });
+
+      expect(result).toEqual(mockUser);
+      expect(mockProvider.signUp).toHaveBeenCalledWith({
+        email: 'test@example.com',
+        password: 'password123',
+        displayName: 'Test User',
+      });
+    });
+
+    it('should sign up without display name', async () => {
+      mockProvider.signUp.mockResolvedValue(mockUser);
+
+      await authCoreService.signUp({
+        email: 'test@example.com',
+        password: 'password123',
+      });
+
+      expect(mockProvider.signUp).toHaveBeenCalledWith({
+        email: 'test@example.com',
+        password: 'password123',
+        displayName: undefined,
+      });
+    });
+
+    it('should throw error when not initialized', async () => {
+      const uninitializedService = new AuthCoreService(DEFAULT_AUTH_CONFIG);
+      
+      await expect(uninitializedService.signUp({
+        email: 'test@example.com',
+        password: 'password123',
+      })).rejects.toThrow('Auth service is not initialized');
+    });
+  });
+
+  describe('signIn', () => {
+    const mockUser: AuthUser = {
+      uid: 'test-uid',
+      email: 'test@example.com',
+      displayName: 'Test User',
+      isAnonymous: false,
+      emailVerified: false,
+      photoURL: null,
+    };
+
+    beforeEach(async () => {
+      await authCoreService.initialize(mockProvider);
+    });
+
+    it('should sign in successfully with valid credentials', async () => {
+      mockProvider.signIn.mockResolvedValue(mockUser);
+
+      const result = await authCoreService.signIn({
+        email: 'test@example.com',
+        password: 'password123',
+      });
+
+      expect(result).toEqual(mockUser);
+      expect(mockProvider.signIn).toHaveBeenCalledWith({
+        email: 'test@example.com',
+        password: 'password123',
+      });
+    });
+
+    it('should throw error when not initialized', async () => {
+      const uninitializedService = new AuthCoreService(DEFAULT_AUTH_CONFIG);
+      
+      await expect(uninitializedService.signIn({
+        email: 'test@example.com',
+        password: 'password123',
+      })).rejects.toThrow('Auth service is not initialized');
+    });
+  });
+
+  describe('signOut', () => {
+    beforeEach(async () => {
+      await authCoreService.initialize(mockProvider);
+    });
+
+    it('should sign out successfully', async () => {
+      await authCoreService.signOut();
+      expect(mockProvider.signOut).toHaveBeenCalled();
+    });
+
+    it('should handle sign out when not initialized', async () => {
+      const uninitializedService = new AuthCoreService(DEFAULT_AUTH_CONFIG);
+      
+      await expect(uninitializedService.signOut()).resolves.not.toThrow();
+    });
+  });
+
+  describe('getCurrentUser', () => {
+    const mockUser: AuthUser = {
+      uid: 'test-uid',
+      email: 'test@example.com',
+      displayName: 'Test User',
+      isAnonymous: false,
+      emailVerified: false,
+      photoURL: null,
+    };
+
+    it('should return null when not initialized', () => {
+      const result = authCoreService.getCurrentUser();
+      expect(result).toBeNull();
+    });
+
+    it('should return current user when initialized', async () => {
+      mockProvider.getCurrentUser.mockReturnValue(mockUser);
+      await authCoreService.initialize(mockProvider);
+
+      const result = authCoreService.getCurrentUser();
+      expect(result).toEqual(mockUser);
+    });
+
+    it('should return null when no current user', async () => {
+      mockProvider.getCurrentUser.mockReturnValue(null);
+      await authCoreService.initialize(mockProvider);
+
+      const result = authCoreService.getCurrentUser();
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('onAuthStateChange', () => {
+    it('should return cleanup function when not initialized', () => {
+      const callback = jest.fn();
+      const cleanup = authCoreService.onAuthStateChange(callback);
+      
+      expect(callback).toHaveBeenCalledWith(null);
+      expect(typeof cleanup).toBe('function');
+    });
+
+    it('should subscribe to auth state changes when initialized', async () => {
+      const callback = jest.fn();
+      const mockCleanup = jest.fn();
+      mockProvider.onAuthStateChange.mockReturnValue(mockCleanup);
+      
+      await authCoreService.initialize(mockProvider);
+      const cleanup = authCoreService.onAuthStateChange(callback);
+
+      expect(mockProvider.onAuthStateChange).toHaveBeenCalledWith(callback);
+      expect(cleanup).toBe(mockCleanup);
+    });
+  });
+
+  describe('getConfig', () => {
+    it('should return the current config', () => {
+      const config = authCoreService.getConfig();
+      expect(config).toEqual(DEFAULT_AUTH_CONFIG);
+    });
+  });
+});

package/src/__tests__/services/AuthPackage.test.ts

@@ -0,0 +1,226 @@
+/**
+ * AuthPackage Tests
+ */
+
+import { 
+  AuthPackage, 
+  initializeAuthPackage, 
+  getAuthPackage, 
+  resetAuthPackage,
+  DEFAULT_AUTH_PACKAGE_CONFIG 
+} from '../../../src/infrastructure/services/AuthPackage';
+import type { IStorageProvider, IUIProvider, IValidationProvider } from '../../../src/infrastructure/services/AuthPackage';
+
+describe('AuthPackage', () => {
+  let mockStorageProvider: jest.Mocked<IStorageProvider>;
+  let mockUIProvider: jest.Mocked<IUIProvider>;
+  let mockValidationProvider: jest.Mocked<IValidationProvider>;
+
+  beforeEach(() => {
+    mockStorageProvider = {
+      get: jest.fn(),
+      set: jest.fn(),
+      remove: jest.fn(),
+    };
+
+    mockUIProvider = {
+      getTheme: jest.fn(),
+      getLocalization: jest.fn(),
+    };
+
+    mockValidationProvider = {
+      validateEmail: jest.fn(),
+      validatePassword: jest.fn(),
+    };
+
+    // Reset package state
+    resetAuthPackage();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with default config', () => {
+      const authPackage = new AuthPackage();
+      const config = authPackage.getConfig();
+      
+      expect(config).toEqual(DEFAULT_AUTH_PACKAGE_CONFIG);
+    });
+
+    it('should merge custom config with defaults', () => {
+      const customConfig = {
+        storageKeys: {
+          guestMode: '@custom_guest_mode',
+          showRegister: 'custom_show_register',
+        },
+        features: {
+          guestMode: false,
+          registration: false,
+          passwordStrength: false,
+        },
+      };
+
+      const authPackage = new AuthPackage(customConfig);
+      const config = authPackage.getConfig();
+      
+      expect(config.storageKeys).toEqual(customConfig.storageKeys);
+      expect(config.features).toEqual(customConfig.features);
+      expect(config.validation).toEqual(DEFAULT_AUTH_PACKAGE_CONFIG.validation);
+      expect(config.ui).toEqual(DEFAULT_AUTH_PACKAGE_CONFIG.ui);
+    });
+
+    it('should deeply merge nested config', () => {
+      const customConfig = {
+        validation: {
+          passwordConfig: {
+            minLength: 12,
+            requireUppercase: true,
+          },
+        },
+      };
+
+      const authPackage = new AuthPackage(customConfig);
+      const config = authPackage.getConfig();
+      
+      expect(config.validation.passwordConfig.minLength).toBe(12);
+      expect(config.validation.passwordConfig.requireUppercase).toBe(true);
+      expect(config.validation.passwordConfig.requireLowercase).toBe(true); // Should keep default
+    });
+  });
+
+  describe('provider setters and getters', () => {
+    let authPackage: AuthPackage;
+
+    beforeEach(() => {
+      authPackage = new AuthPackage();
+    });
+
+    it('should set and get storage provider', () => {
+      authPackage.setStorageProvider(mockStorageProvider);
+      expect(authPackage.getStorageProvider()).toBe(mockStorageProvider);
+    });
+
+    it('should set and get UI provider', () => {
+      authPackage.setUIProvider(mockUIProvider);
+      expect(authPackage.getUIProvider()).toBe(mockUIProvider);
+    });
+
+    it('should set and get validation provider', () => {
+      authPackage.setValidationProvider(mockValidationProvider);
+      expect(authPackage.getValidationProvider()).toBe(mockValidationProvider);
+    });
+  });
+
+  describe('isFeatureEnabled', () => {
+    let authPackage: AuthPackage;
+
+    beforeEach(() => {
+      authPackage = new AuthPackage();
+    });
+
+    it('should return feature status from config', () => {
+      expect(authPackage.isFeatureEnabled('guestMode')).toBe(true);
+      expect(authPackage.isFeatureEnabled('registration')).toBe(true);
+      expect(authPackage.isFeatureEnabled('passwordStrength')).toBe(true);
+    });
+
+    it('should return custom feature status', () => {
+      const customConfig = {
+        features: {
+          guestMode: false,
+          registration: false,
+          passwordStrength: false,
+        },
+      };
+
+      const customPackage = new AuthPackage(customConfig);
+      
+      expect(customPackage.isFeatureEnabled('guestMode')).toBe(false);
+      expect(customPackage.isFeatureEnabled('registration')).toBe(false);
+      expect(customPackage.isFeatureEnabled('passwordStrength')).toBe(false);
+    });
+  });
+
+  describe('global package instance', () => {
+    it('should initialize package globally', () => {
+      const customConfig = {
+        storageKeys: {
+          guestMode: '@global_guest_mode',
+        },
+      };
+
+      const packageInstance = initializeAuthPackage(customConfig);
+      expect(packageInstance.getConfig().storageKeys.guestMode).toBe('@global_guest_mode');
+    });
+
+    it('should return existing package instance', () => {
+      const firstInstance = initializeAuthPackage();
+      const secondInstance = getAuthPackage();
+      
+      expect(firstInstance).toBe(secondInstance);
+    });
+
+    it('should return null when no package initialized', () => {
+      resetAuthPackage();
+      const packageInstance = getAuthPackage();
+      expect(packageInstance).toBeNull();
+    });
+
+    it('should not reinitialize when already initialized', () => {
+      const firstInstance = initializeAuthPackage();
+      const secondInstance = initializeAuthPackage({
+        storageKeys: { guestMode: '@different' },
+      });
+      
+      expect(firstInstance).toBe(secondInstance);
+      expect(secondInstance.getConfig().storageKeys.guestMode).toBe('@auth_guest_mode'); // Should keep original
+    });
+
+    it('should reset package instance', () => {
+      initializeAuthPackage();
+      expect(getAuthPackage()).not.toBeNull();
+      
+      resetAuthPackage();
+      expect(getAuthPackage()).toBeNull();
+    });
+  });
+
+  describe('provider integration', () => {
+    let authPackage: AuthPackage;
+
+    beforeEach(() => {
+      authPackage = new AuthPackage();
+      authPackage.setStorageProvider(mockStorageProvider);
+      authPackage.setUIProvider(mockUIProvider);
+      authPackage.setValidationProvider(mockValidationProvider);
+    });
+
+    it('should integrate all providers', () => {
+      expect(authPackage.getStorageProvider()).toBe(mockStorageProvider);
+      expect(authPackage.getUIProvider()).toBe(mockUIProvider);
+      expect(authPackage.getValidationProvider()).toBe(mockValidationProvider);
+    });
+  });
+
+  describe('config validation', () => {
+    it('should handle empty config', () => {
+      const authPackage = new AuthPackage({});
+      const config = authPackage.getConfig();
+      
+      expect(config).toEqual(DEFAULT_AUTH_PACKAGE_CONFIG);
+    });
+
+    it('should handle partial config', () => {
+      const partialConfig = {
+        features: {
+          guestMode: false,
+        },
+      };
+
+      const authPackage = new AuthPackage(partialConfig);
+      const config = authPackage.getConfig();
+      
+      expect(config.features.guestMode).toBe(false);
+      expect(config.features.registration).toBe(true); // Should keep default
+      expect(config.features.passwordStrength).toBe(true); // Should keep default
+    });
+  });
+});