@umituz/react-native-auth 1.11.0 → 2.0.1

package/src/infrastructure/services/AuthCoreService.ts

@@ -0,0 +1,138 @@
+/**
+ * Auth Core Service
+ * Handles core authentication operations
+ */
+
+import type { IAuthService, SignUpParams, SignInParams } from "../../application/ports/IAuthService";
+import type { IAuthProvider } from "../../application/ports/IAuthProvider";
+import type { AuthUser } from "../../domain/entities/AuthUser";
+import type { AuthConfig } from "../../domain/value-objects/AuthConfig";
+import {
+  AuthInitializationError,
+  AuthValidationError,
+  AuthWeakPasswordError,
+  AuthInvalidEmailError,
+} from "../../domain/errors/AuthError";
+import {
+  validateEmail,
+  validatePasswordForLogin,
+  validatePasswordForRegister,
+  validateDisplayName,
+} from "../utils/AuthValidation";
+
+export class AuthCoreService implements Partial<IAuthService> {
+  private provider: IAuthProvider | null = null;
+  private config: AuthConfig;
+
+  constructor(config: AuthConfig) {
+    this.config = config;
+  }
+
+  async initialize(providerOrAuth: IAuthProvider | any): Promise<void> {
+    if (!providerOrAuth) {
+      throw new AuthInitializationError("Auth provider or Firebase Auth instance is required");
+    }
+
+    // Check if it's a Firebase Auth instance (has currentUser property)
+    if ("currentUser" in providerOrAuth) {
+      // Import FirebaseAuthProvider directly
+      const { FirebaseAuthProvider } = require("../providers/FirebaseAuthProvider");
+      const firebaseProvider = new FirebaseAuthProvider(providerOrAuth);
+      await firebaseProvider.initialize();
+      this.provider = firebaseProvider;
+    } else {
+      this.provider = providerOrAuth as IAuthProvider;
+      await this.provider.initialize();
+    }
+  }
+
+  isInitialized(): boolean {
+    return this.provider !== null && this.provider.isInitialized();
+  }
+
+  private getProvider(): IAuthProvider {
+    if (!this.provider || !this.provider.isInitialized()) {
+      throw new AuthInitializationError("Auth service is not initialized");
+    }
+    return this.provider;
+  }
+
+  async signUp(params: SignUpParams): Promise<AuthUser> {
+    const provider = this.getProvider();
+
+    // Validate email
+    const emailResult = validateEmail(params.email);
+    if (!emailResult.isValid) {
+      throw new AuthInvalidEmailError(emailResult.error);
+    }
+
+    // Validate display name if provided
+    if (params.displayName) {
+      const nameResult = validateDisplayName(params.displayName);
+      if (!nameResult.isValid) {
+        throw new AuthValidationError(nameResult.error || "Invalid name", "displayName");
+      }
+    }
+
+    // Validate password strength for registration
+    const passwordResult = validatePasswordForRegister(params.password, this.config.password);
+    if (!passwordResult.isValid) {
+      throw new AuthWeakPasswordError(passwordResult.error);
+    }
+
+    return provider.signUp({
+      email: params.email,
+      password: params.password,
+      displayName: params.displayName,
+    });
+  }
+
+  async signIn(params: SignInParams): Promise<AuthUser> {
+    const provider = this.getProvider();
+
+    // Validate email format
+    const emailResult = validateEmail(params.email);
+    if (!emailResult.isValid) {
+      throw new AuthInvalidEmailError(emailResult.error);
+    }
+
+    // For login, only check if password is provided (no strength requirements)
+    const passwordResult = validatePasswordForLogin(params.password);
+    if (!passwordResult.isValid) {
+      throw new AuthValidationError(passwordResult.error || "Password is required", "password");
+    }
+
+    return provider.signIn({
+      email: params.email,
+      password: params.password,
+    });
+  }
+
+  async signOut(): Promise<void> {
+    if (!this.provider) {
+      return;
+    }
+
+    await this.provider.signOut();
+  }
+
+  getCurrentUser(): AuthUser | null {
+    if (!this.provider) {
+      return null;
+    }
+    return this.provider.getCurrentUser();
+  }
+
+  onAuthStateChange(callback: (user: AuthUser | null) => void): () => void {
+    if (!this.provider) {
+      callback(null);
+      return () => {};
+    }
+
+    return this.provider.onAuthStateChange(callback);
+  }
+
+  getConfig(): AuthConfig {
+    return this.config;
+  }
+}

package/src/infrastructure/services/AuthEventService.ts

@@ -0,0 +1,115 @@
+/**
+ * Auth Event Service
+ * Handles authentication event emission and management
+ */
+
+import { DeviceEventEmitter } from "react-native";
+
+export interface AuthEventPayload {
+  userId?: string;
+  error?: string;
+  timestamp: number;
+}
+
+export interface AuthEventListener {
+  (payload: AuthEventPayload): void;
+}
+
+export class AuthEventService {
+  private static instance: AuthEventService;
+  private listeners: Map<string, AuthEventListener[]> = new Map();
+
+  private constructor() {}
+
+  static getInstance(): AuthEventService {
+    if (!AuthEventService.instance) {
+      AuthEventService.instance = new AuthEventService();
+    }
+    return AuthEventService.instance;
+  }
+
+  emitUserAuthenticated(userId: string): void {
+    const payload: AuthEventPayload = {
+      userId,
+      timestamp: Date.now(),
+    };
+
+    DeviceEventEmitter.emit("user-authenticated", payload);
+    this.notifyListeners("user-authenticated", payload);
+  }
+
+  emitGuestModeEnabled(): void {
+    const payload: AuthEventPayload = {
+      timestamp: Date.now(),
+    };
+
+    DeviceEventEmitter.emit("guest-mode-enabled", payload);
+    this.notifyListeners("guest-mode-enabled", payload);
+  }
+
+  emitAuthError(error: string): void {
+    const payload: AuthEventPayload = {
+      error,
+      timestamp: Date.now(),
+    };
+
+    DeviceEventEmitter.emit("auth-error", payload);
+    this.notifyListeners("auth-error", payload);
+  }
+
+  addEventListener(event: string, listener: AuthEventListener): () => void {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+
+    const eventListeners = this.listeners.get(event)!;
+    eventListeners.push(listener);
+
+    // Return cleanup function
+    return () => {
+      const index = eventListeners.indexOf(listener);
+      if (index > -1) {
+        eventListeners.splice(index, 1);
+      }
+    };
+  }
+
+  removeAllListeners(event?: string): void {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+  }
+
+  private notifyListeners(event: string, payload: AuthEventPayload): void {
+    const eventListeners = this.listeners.get(event);
+    if (eventListeners) {
+      eventListeners.forEach(listener => {
+        try {
+          listener(payload);
+        } catch (error) {
+          if (__DEV__) {
+            console.error(`Error in auth event listener for ${event}:`, error);
+          }
+        }
+      });
+    }
+  }
+}
+
+// Export singleton instance for backward compatibility
+export const authEventService = AuthEventService.getInstance();
+
+// Legacy functions for backward compatibility
+export function emitUserAuthenticated(userId: string): void {
+  authEventService.emitUserAuthenticated(userId);
+}
+
+export function emitGuestModeEnabled(): void {
+  authEventService.emitGuestModeEnabled();
+}
+
+export function emitAuthError(error: string): void {
+  authEventService.emitAuthError(error);
+}

package/src/infrastructure/services/AuthPackage.ts

@@ -0,0 +1,148 @@
+/**
+ * Auth Package Configuration
+ * Centralized configuration for the auth package
+ */
+
+import type { AuthConfig, PasswordConfig } from "../../domain/value-objects/AuthConfig";
+
+export interface AuthPackageConfig {
+  storageKeys: {
+    guestMode: string;
+    showRegister: string;
+  };
+  validation: {
+    emailRegex: RegExp;
+    passwordConfig: PasswordConfig;
+  };
+  ui: {
+    theme?: any;
+    localization?: any;
+  };
+  features: {
+    guestMode: boolean;
+    registration: boolean;
+    passwordStrength: boolean;
+  };
+}
+
+export const DEFAULT_AUTH_PACKAGE_CONFIG: AuthPackageConfig = {
+  storageKeys: {
+    guestMode: "@auth_guest_mode",
+    showRegister: "auth_show_register",
+  },
+  validation: {
+    emailRegex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+    passwordConfig: {
+      minLength: 8,
+      requireUppercase: true,
+      requireLowercase: true,
+      requireNumber: true,
+      requireSpecialChar: false,
+    },
+  },
+  ui: {
+    theme: undefined,
+    localization: undefined,
+  },
+  features: {
+    guestMode: true,
+    registration: true,
+    passwordStrength: true,
+  },
+};
+
+export interface IStorageProvider {
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string): Promise<void>;
+  remove(key: string): Promise<void>;
+}
+
+export interface IUIProvider {
+  getTheme(): any;
+  getLocalization(): any;
+}
+
+export interface IValidationProvider {
+  validateEmail(email: string): { isValid: boolean; error?: string };
+  validatePassword(password: string, config: PasswordConfig): { isValid: boolean; error?: string };
+}
+
+export class AuthPackage {
+  private config: AuthPackageConfig;
+  private storageProvider?: IStorageProvider;
+  private uiProvider?: IUIProvider;
+  private validationProvider?: IValidationProvider;
+
+  constructor(config: Partial<AuthPackageConfig> = {}) {
+    this.config = {
+      ...DEFAULT_AUTH_PACKAGE_CONFIG,
+      ...config,
+      validation: {
+        ...DEFAULT_AUTH_PACKAGE_CONFIG.validation,
+        ...config.validation,
+        passwordConfig: {
+          ...DEFAULT_AUTH_PACKAGE_CONFIG.validation.passwordConfig,
+          ...config.validation?.passwordConfig,
+        },
+      },
+      ui: {
+        ...DEFAULT_AUTH_PACKAGE_CONFIG.ui,
+        ...config.ui,
+      },
+      features: {
+        ...DEFAULT_AUTH_PACKAGE_CONFIG.features,
+        ...config.features,
+      },
+    };
+  }
+
+  setStorageProvider(provider: IStorageProvider): void {
+    this.storageProvider = provider;
+  }
+
+  setUIProvider(provider: IUIProvider): void {
+    this.uiProvider = provider;
+  }
+
+  setValidationProvider(provider: IValidationProvider): void {
+    this.validationProvider = provider;
+  }
+
+  getConfig(): AuthPackageConfig {
+    return this.config;
+  }
+
+  getStorageProvider(): IStorageProvider | undefined {
+    return this.storageProvider;
+  }
+
+  getUIProvider(): IUIProvider | undefined {
+    return this.uiProvider;
+  }
+
+  getValidationProvider(): IValidationProvider | undefined {
+    return this.validationProvider;
+  }
+
+  isFeatureEnabled(feature: keyof AuthPackageConfig['features']): boolean {
+    return this.config.features[feature];
+  }
+}
+
+// Global package instance
+let packageInstance: AuthPackage | null = null;
+
+export function initializeAuthPackage(config: Partial<AuthPackageConfig> = {}): AuthPackage {
+  if (!packageInstance) {
+    packageInstance = new AuthPackage(config);
+  }
+  return packageInstance;
+}
+
+export function getAuthPackage(): AuthPackage | null {
+  return packageInstance;
+}
+
+export function resetAuthPackage(): void {
+  packageInstance = null;
+}

package/src/infrastructure/services/AuthService.ts

@@ -1,6 +1,6 @@
 /**
  * Auth Service
- * Provider-agnostic authentication orchestrator
+ * Orchestrates authentication operations using composition
  */
 
 import type { Auth } from "firebase/auth";
@@ -9,29 +9,19 @@ import type { IAuthProvider } from "../../application/ports/IAuthProvider";
 import type { AuthUser } from "../../domain/entities/AuthUser";
 import type { AuthConfig } from "../../domain/value-objects/AuthConfig";
 import { DEFAULT_AUTH_CONFIG } from "../../domain/value-objects/AuthConfig";
-import {
-  AuthInitializationError,
-  AuthValidationError,
-  AuthWeakPasswordError,
-  AuthInvalidEmailError,
-} from "../../domain/errors/AuthError";
-import {
-  validateEmail,
-  validatePasswordForLogin,
-  validatePasswordForRegister,
-  validateDisplayName,
-} from "../utils/AuthValidation";
-import { FirebaseAuthProvider } from "../providers/FirebaseAuthProvider";
-import { emitUserAuthenticated, emitGuestModeEnabled } from "../utils/AuthEventEmitter";
-import { loadGuestMode, saveGuestMode, clearGuestMode } from "../storage/GuestModeStorage";
+import { AuthCoreService } from "./AuthCoreService";
+import { GuestModeService, type IStorageProvider } from "./GuestModeService";
+import { authEventService } from "./AuthEventService";
+import { initializeAuthPackage, getAuthPackage } from "./AuthPackage";
 
 export class AuthService implements IAuthService {
-  private provider: IAuthProvider | null = null;
-  private config: AuthConfig;
-  private isGuestMode: boolean = false;
+  private coreService: AuthCoreService;
+  private guestModeService: GuestModeService;
+  private storageProvider?: IStorageProvider;
+  private initialized: boolean = false;
 
-  constructor(config: Partial<AuthConfig> = {}) {
-    this.config = {
+  constructor(config: Partial<AuthConfig> = {}, storageProvider?: IStorageProvider) {
+    const authConfig = {
       ...DEFAULT_AUTH_CONFIG,
       ...config,
       password: {
@@ -39,160 +29,101 @@ export class AuthService implements IAuthService {
         ...config.password,
       },
     };
+
+    this.coreService = new AuthCoreService(authConfig);
+    this.guestModeService = new GuestModeService();
+    this.storageProvider = storageProvider;
   }
 
   async initialize(providerOrAuth: IAuthProvider | Auth): Promise<void> {
-    if (!providerOrAuth) {
-      throw new AuthInitializationError("Auth provider or Firebase Auth instance is required");
+    if (this.initialized) {
+      return;
     }
 
-    // Check if it's a Firebase Auth instance (has currentUser property)
-    if ("currentUser" in providerOrAuth) {
-      const firebaseProvider = new FirebaseAuthProvider(providerOrAuth as Auth);
-      await firebaseProvider.initialize();
-      this.provider = firebaseProvider;
-    } else {
-      this.provider = providerOrAuth as IAuthProvider;
-      await this.provider.initialize();
+    // Initialize core service
+    await this.coreService.initialize(providerOrAuth);
+
+    // Initialize guest mode if storage provider is available
+    if (this.storageProvider) {
+      await this.guestModeService.load(this.storageProvider);
     }
 
-    this.isGuestMode = await loadGuestMode();
+    this.initialized = true;
   }
 
   isInitialized(): boolean {
-    return this.provider !== null && this.provider.isInitialized();
-  }
-
-  private getProvider(): IAuthProvider {
-    if (!this.provider || !this.provider.isInitialized()) {
-      throw new AuthInitializationError("Auth service is not initialized");
-    }
-    return this.provider;
+    return this.initialized && this.coreService.isInitialized();
   }
 
   async signUp(params: SignUpParams): Promise<AuthUser> {
-    const provider = this.getProvider();
-
-    // Validate email
-    const emailResult = validateEmail(params.email);
-    if (!emailResult.isValid) {
-      throw new AuthInvalidEmailError(emailResult.error);
-    }
-
-    // Validate display name if provided
-    if (params.displayName) {
-      const nameResult = validateDisplayName(params.displayName);
-      if (!nameResult.isValid) {
-        throw new AuthValidationError(nameResult.error || "Invalid name", "displayName");
-      }
-    }
-
-    // Validate password strength for registration
-    const passwordResult = validatePasswordForRegister(params.password, this.config.password);
-    if (!passwordResult.isValid) {
-      throw new AuthWeakPasswordError(passwordResult.error);
-    }
-
-    const user = await provider.signUp({
-      email: params.email,
-      password: params.password,
-      displayName: params.displayName,
-    });
+    const user = await this.coreService.signUp(params);
 
     // Clear guest mode when user signs up
-    if (this.isGuestMode) {
-      this.isGuestMode = false;
-      await clearGuestMode();
+    if (this.guestModeService.getIsGuestMode() && this.storageProvider) {
+      await this.guestModeService.clear(this.storageProvider);
     }
 
-    emitUserAuthenticated(user.uid);
+    authEventService.emitUserAuthenticated(user.uid);
     return user;
   }
 
   async signIn(params: SignInParams): Promise<AuthUser> {
-    const provider = this.getProvider();
-
-    // Validate email format
-    const emailResult = validateEmail(params.email);
-    if (!emailResult.isValid) {
-      throw new AuthInvalidEmailError(emailResult.error);
-    }
-
-    // For login, only check if password is provided (no strength requirements)
-    const passwordResult = validatePasswordForLogin(params.password);
-    if (!passwordResult.isValid) {
-      throw new AuthValidationError(passwordResult.error || "Password is required", "password");
-    }
-
-    const user = await provider.signIn({
-      email: params.email,
-      password: params.password,
-    });
+    const user = await this.coreService.signIn(params);
 
     // Clear guest mode when user signs in
-    if (this.isGuestMode) {
-      this.isGuestMode = false;
-      await clearGuestMode();
+    if (this.guestModeService.getIsGuestMode() && this.storageProvider) {
+      await this.guestModeService.clear(this.storageProvider);
     }
 
-    emitUserAuthenticated(user.uid);
+    authEventService.emitUserAuthenticated(user.uid);
     return user;
   }
 
   async signOut(): Promise<void> {
-    if (!this.provider) {
-      this.isGuestMode = false;
-      await clearGuestMode();
-      return;
-    }
+    await this.coreService.signOut();
 
-    await this.provider.signOut();
+    // Clear guest mode if signing out explicitly
+    if (this.guestModeService.getIsGuestMode() && this.storageProvider) {
+      await this.guestModeService.clear(this.storageProvider);
+    }
   }
 
   async setGuestMode(): Promise<void> {
-    // Sign out from provider if logged in
-    if (this.provider?.getCurrentUser()) {
-      try {
-        await this.provider.signOut();
-      } catch {
-        // Ignore sign out errors when switching to guest mode
-      }
+    if (!this.storageProvider) {
+      throw new Error("Storage provider is required for guest mode");
     }
 
-    this.isGuestMode = true;
-    await saveGuestMode(true);
-    emitGuestModeEnabled();
+    // No provider needed for guest mode enablement
+    
+    await this.guestModeService.enable(this.storageProvider);
   }
 
   getCurrentUser(): AuthUser | null {
-    if (!this.provider) {
+    if (this.guestModeService.getIsGuestMode()) {
       return null;
     }
-    return this.provider.getCurrentUser();
+    return this.coreService.getCurrentUser();
   }
 
   getIsGuestMode(): boolean {
-    return this.isGuestMode;
+    return this.guestModeService.getIsGuestMode();
   }
 
   onAuthStateChange(callback: (user: AuthUser | null) => void): () => void {
-    if (!this.provider) {
-      callback(null);
-      return () => {};
-    }
-
-    return this.provider.onAuthStateChange((user) => {
-      // Don't update if in guest mode
-      if (!this.isGuestMode) {
-        callback(user);
-      } else {
-        callback(null);
-      }
-    });
+    const wrappedCallback = this.guestModeService.wrapAuthStateCallback(callback);
+    return this.coreService.onAuthStateChange(wrappedCallback);
   }
 
   getConfig(): AuthConfig {
-    return this.config;
+    return this.coreService.getConfig();
+  }
+
+  getCoreService(): AuthCoreService {
+    return this.coreService;
+  }
+
+  getGuestModeService(): GuestModeService {
+    return this.guestModeService;
   }
 }
 
@@ -204,10 +135,13 @@ let authServiceInstance: AuthService | null = null;
  */
 export async function initializeAuthService(
   providerOrAuth: IAuthProvider | Auth,
-  config?: Partial<AuthConfig>
+  config?: Partial<AuthConfig>,
+  storageProvider?: IStorageProvider
 ): Promise<AuthService> {
   if (!authServiceInstance) {
-    authServiceInstance = new AuthService(config);
+    // Initialize package if not already done
+    const packageConfig = getAuthPackage()?.getConfig();
+    authServiceInstance = new AuthService(config, storageProvider);
   }
   await authServiceInstance.initialize(providerOrAuth);
   return authServiceInstance;