@umituz/react-native-auth 1.11.0 → 2.0.1

package/lib/infrastructure/adapters/StorageProviderAdapter.js

@@ -0,0 +1,72 @@
+/**
+ * Storage Provider Adapter
+ * Adapts external storage implementations to our IStorageProvider interface
+ */
+export class StorageProviderAdapter {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async get(key) {
+        try {
+            if (this.storage.getString) {
+                // @umituz/react-native-storage format
+                const result = await this.storage.getString(key, null);
+                return result?.value ?? null;
+            }
+            else if (this.storage.getItem) {
+                // AsyncStorage format
+                return await this.storage.getItem(key);
+            }
+            else {
+                throw new Error("Unsupported storage implementation");
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    async set(key, value) {
+        try {
+            if (this.storage.setString) {
+                // @umituz/react-native-storage format
+                await this.storage.setString(key, value);
+            }
+            else if (this.storage.setItem) {
+                // AsyncStorage format
+                await this.storage.setItem(key, value);
+            }
+            else {
+                throw new Error("Unsupported storage implementation");
+            }
+        }
+        catch (error) {
+            if (__DEV__) {
+                console.warn("[StorageProviderAdapter] Failed to set value:", error);
+            }
+            throw error;
+        }
+    }
+    async remove(key) {
+        try {
+            if (this.storage.removeItem) {
+                // Both AsyncStorage and @umituz/react-native-storage support removeItem
+                await this.storage.removeItem(key);
+            }
+            else {
+                throw new Error("Unsupported storage implementation");
+            }
+        }
+        catch (error) {
+            if (__DEV__) {
+                console.warn("[StorageProviderAdapter] Failed to remove value:", error);
+            }
+            throw error;
+        }
+    }
+}
+/**
+ * Create storage provider from various storage implementations
+ */
+export function createStorageProvider(storage) {
+    return new StorageProviderAdapter(storage);
+}

package/lib/infrastructure/adapters/UIProviderAdapter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * UI Provider Adapter
+ * Adapts external UI implementations to our IUIProvider interface
+ */
+import type { IUIProvider } from "../services/AuthPackage";
+export declare class UIProviderAdapter implements IUIProvider {
+    private theme;
+    private localization;
+    constructor(theme?: any, localization?: any);
+    getTheme(): any;
+    getLocalization(): any;
+    updateTheme(theme: any): void;
+    updateLocalization(localization: any): void;
+}
+/**
+ * Create UI provider from theme and localization implementations
+ */
+export declare function createUIProvider(theme?: any, localization?: any): IUIProvider;

package/lib/infrastructure/adapters/UIProviderAdapter.js

@@ -0,0 +1,28 @@
+/**
+ * UI Provider Adapter
+ * Adapts external UI implementations to our IUIProvider interface
+ */
+export class UIProviderAdapter {
+    constructor(theme, localization) {
+        this.theme = theme;
+        this.localization = localization;
+    }
+    getTheme() {
+        return this.theme;
+    }
+    getLocalization() {
+        return this.localization;
+    }
+    updateTheme(theme) {
+        this.theme = theme;
+    }
+    updateLocalization(localization) {
+        this.localization = localization;
+    }
+}
+/**
+ * Create UI provider from theme and localization implementations
+ */
+export function createUIProvider(theme, localization) {
+    return new UIProviderAdapter(theme, localization);
+}

package/lib/infrastructure/providers/FirebaseAuthProvider.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Firebase Auth Provider
+ * IAuthProvider implementation for Firebase Authentication
+ */
+import { type Auth } from "firebase/auth";
+import type { IAuthProvider, AuthCredentials, SignUpCredentials } from "../../application/ports/IAuthProvider";
+import type { AuthUser } from "../../domain/entities/AuthUser";
+export declare class FirebaseAuthProvider implements IAuthProvider {
+    private auth;
+    constructor(auth?: Auth);
+    initialize(): Promise<void>;
+    setAuth(auth: Auth): void;
+    isInitialized(): boolean;
+    signIn(credentials: AuthCredentials): Promise<AuthUser>;
+    signUp(credentials: SignUpCredentials): Promise<AuthUser>;
+    signOut(): Promise<void>;
+    getCurrentUser(): AuthUser | null;
+    onAuthStateChange(callback: (user: AuthUser | null) => void): () => void;
+}

package/lib/infrastructure/providers/FirebaseAuthProvider.js

@@ -0,0 +1,94 @@
+/**
+ * Firebase Auth Provider
+ * IAuthProvider implementation for Firebase Authentication
+ */
+import { createUserWithEmailAndPassword, signInWithEmailAndPassword, signOut as firebaseSignOut, onAuthStateChanged, updateProfile, } from "firebase/auth";
+import { mapFirebaseAuthError } from "../utils/AuthErrorMapper";
+import { mapToAuthUser } from "../utils/UserMapper";
+export class FirebaseAuthProvider {
+    constructor(auth) {
+        this.auth = null;
+        if (auth) {
+            this.auth = auth;
+        }
+    }
+    async initialize() {
+        if (!this.auth) {
+            throw new Error("Firebase Auth instance must be provided");
+        }
+    }
+    setAuth(auth) {
+        this.auth = auth;
+    }
+    isInitialized() {
+        return this.auth !== null;
+    }
+    async signIn(credentials) {
+        if (!this.auth) {
+            throw new Error("Firebase Auth is not initialized");
+        }
+        try {
+            const userCredential = await signInWithEmailAndPassword(this.auth, credentials.email.trim(), credentials.password);
+            const user = mapToAuthUser(userCredential.user);
+            if (!user) {
+                throw new Error("Failed to sign in");
+            }
+            return user;
+        }
+        catch (error) {
+            throw mapFirebaseAuthError(error);
+        }
+    }
+    async signUp(credentials) {
+        if (!this.auth) {
+            throw new Error("Firebase Auth is not initialized");
+        }
+        try {
+            const userCredential = await createUserWithEmailAndPassword(this.auth, credentials.email.trim(), credentials.password);
+            if (credentials.displayName && userCredential.user) {
+                try {
+                    await updateProfile(userCredential.user, {
+                        displayName: credentials.displayName.trim(),
+                    });
+                }
+                catch {
+                    // Don't fail signup if display name update fails
+                }
+            }
+            const user = mapToAuthUser(userCredential.user);
+            if (!user) {
+                throw new Error("Failed to create user account");
+            }
+            return user;
+        }
+        catch (error) {
+            throw mapFirebaseAuthError(error);
+        }
+    }
+    async signOut() {
+        if (!this.auth) {
+            return;
+        }
+        try {
+            await firebaseSignOut(this.auth);
+        }
+        catch (error) {
+            throw mapFirebaseAuthError(error);
+        }
+    }
+    getCurrentUser() {
+        if (!this.auth?.currentUser) {
+            return null;
+        }
+        return mapToAuthUser(this.auth.currentUser);
+    }
+    onAuthStateChange(callback) {
+        if (!this.auth) {
+            callback(null);
+            return () => { };
+        }
+        return onAuthStateChanged(this.auth, (user) => {
+            callback(mapToAuthUser(user));
+        });
+    }
+}

package/lib/infrastructure/services/AuthCoreService.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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";
+export declare class AuthCoreService implements Partial<IAuthService> {
+    private provider;
+    private config;
+    constructor(config: AuthConfig);
+    initialize(providerOrAuth: IAuthProvider | any): Promise<void>;
+    isInitialized(): boolean;
+    private getProvider;
+    signUp(params: SignUpParams): Promise<AuthUser>;
+    signIn(params: SignInParams): Promise<AuthUser>;
+    signOut(): Promise<void>;
+    getCurrentUser(): AuthUser | null;
+    onAuthStateChange(callback: (user: AuthUser | null) => void): () => void;
+    getConfig(): AuthConfig;
+}

package/lib/infrastructure/services/AuthCoreService.js

@@ -0,0 +1,102 @@
+/**
+ * Auth Core Service
+ * Handles core authentication operations
+ */
+import { AuthInitializationError, AuthValidationError, AuthWeakPasswordError, AuthInvalidEmailError, } from "../../domain/errors/AuthError";
+import { validateEmail, validatePasswordForLogin, validatePasswordForRegister, validateDisplayName, } from "../utils/AuthValidation";
+export class AuthCoreService {
+    constructor(config) {
+        this.provider = null;
+        this.config = config;
+    }
+    async initialize(providerOrAuth) {
+        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;
+            await this.provider.initialize();
+        }
+    }
+    isInitialized() {
+        return this.provider !== null && this.provider.isInitialized();
+    }
+    getProvider() {
+        if (!this.provider || !this.provider.isInitialized()) {
+            throw new AuthInitializationError("Auth service is not initialized");
+        }
+        return this.provider;
+    }
+    async signUp(params) {
+        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) {
+        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() {
+        if (!this.provider) {
+            return;
+        }
+        await this.provider.signOut();
+    }
+    getCurrentUser() {
+        if (!this.provider) {
+            return null;
+        }
+        return this.provider.getCurrentUser();
+    }
+    onAuthStateChange(callback) {
+        if (!this.provider) {
+            callback(null);
+            return () => { };
+        }
+        return this.provider.onAuthStateChange(callback);
+    }
+    getConfig() {
+        return this.config;
+    }
+}

package/lib/infrastructure/services/AuthEventService.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Auth Event Service
+ * Handles authentication event emission and management
+ */
+export interface AuthEventPayload {
+    userId?: string;
+    error?: string;
+    timestamp: number;
+}
+export interface AuthEventListener {
+    (payload: AuthEventPayload): void;
+}
+export declare class AuthEventService {
+    private static instance;
+    private listeners;
+    private constructor();
+    static getInstance(): AuthEventService;
+    emitUserAuthenticated(userId: string): void;
+    emitGuestModeEnabled(): void;
+    emitAuthError(error: string): void;
+    addEventListener(event: string, listener: AuthEventListener): () => void;
+    removeAllListeners(event?: string): void;
+    private notifyListeners;
+}
+export declare const authEventService: AuthEventService;
+export declare function emitUserAuthenticated(userId: string): void;
+export declare function emitGuestModeEnabled(): void;
+export declare function emitAuthError(error: string): void;

package/lib/infrastructure/services/AuthEventService.js

@@ -0,0 +1,88 @@
+/**
+ * Auth Event Service
+ * Handles authentication event emission and management
+ */
+import { DeviceEventEmitter } from "react-native";
+export class AuthEventService {
+    constructor() {
+        this.listeners = new Map();
+    }
+    static getInstance() {
+        if (!AuthEventService.instance) {
+            AuthEventService.instance = new AuthEventService();
+        }
+        return AuthEventService.instance;
+    }
+    emitUserAuthenticated(userId) {
+        const payload = {
+            userId,
+            timestamp: Date.now(),
+        };
+        DeviceEventEmitter.emit("user-authenticated", payload);
+        this.notifyListeners("user-authenticated", payload);
+    }
+    emitGuestModeEnabled() {
+        const payload = {
+            timestamp: Date.now(),
+        };
+        DeviceEventEmitter.emit("guest-mode-enabled", payload);
+        this.notifyListeners("guest-mode-enabled", payload);
+    }
+    emitAuthError(error) {
+        const payload = {
+            error,
+            timestamp: Date.now(),
+        };
+        DeviceEventEmitter.emit("auth-error", payload);
+        this.notifyListeners("auth-error", payload);
+    }
+    addEventListener(event, listener) {
+        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) {
+        if (event) {
+            this.listeners.delete(event);
+        }
+        else {
+            this.listeners.clear();
+        }
+    }
+    notifyListeners(event, payload) {
+        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) {
+    authEventService.emitUserAuthenticated(userId);
+}
+export function emitGuestModeEnabled() {
+    authEventService.emitGuestModeEnabled();
+}
+export function emitAuthError(error) {
+    authEventService.emitAuthError(error);
+}

package/lib/infrastructure/services/AuthPackage.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Auth Package Configuration
+ * Centralized configuration for the auth package
+ */
+import type { 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 declare const DEFAULT_AUTH_PACKAGE_CONFIG: AuthPackageConfig;
+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 declare class AuthPackage {
+    private config;
+    private storageProvider?;
+    private uiProvider?;
+    private validationProvider?;
+    constructor(config?: Partial<AuthPackageConfig>);
+    setStorageProvider(provider: IStorageProvider): void;
+    setUIProvider(provider: IUIProvider): void;
+    setValidationProvider(provider: IValidationProvider): void;
+    getConfig(): AuthPackageConfig;
+    getStorageProvider(): IStorageProvider | undefined;
+    getUIProvider(): IUIProvider | undefined;
+    getValidationProvider(): IValidationProvider | undefined;
+    isFeatureEnabled(feature: keyof AuthPackageConfig['features']): boolean;
+}
+export declare function initializeAuthPackage(config?: Partial<AuthPackageConfig>): AuthPackage;
+export declare function getAuthPackage(): AuthPackage | null;
+export declare function resetAuthPackage(): void;

package/lib/infrastructure/services/AuthPackage.js

@@ -0,0 +1,91 @@
+/**
+ * Auth Package Configuration
+ * Centralized configuration for the auth package
+ */
+export const DEFAULT_AUTH_PACKAGE_CONFIG = {
+    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 class AuthPackage {
+    constructor(config = {}) {
+        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) {
+        this.storageProvider = provider;
+    }
+    setUIProvider(provider) {
+        this.uiProvider = provider;
+    }
+    setValidationProvider(provider) {
+        this.validationProvider = provider;
+    }
+    getConfig() {
+        return this.config;
+    }
+    getStorageProvider() {
+        return this.storageProvider;
+    }
+    getUIProvider() {
+        return this.uiProvider;
+    }
+    getValidationProvider() {
+        return this.validationProvider;
+    }
+    isFeatureEnabled(feature) {
+        return this.config.features[feature];
+    }
+}
+// Global package instance
+let packageInstance = null;
+export function initializeAuthPackage(config = {}) {
+    if (!packageInstance) {
+        packageInstance = new AuthPackage(config);
+    }
+    return packageInstance;
+}
+export function getAuthPackage() {
+    return packageInstance;
+}
+export function resetAuthPackage() {
+    packageInstance = null;
+}

package/lib/infrastructure/services/AuthService.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Auth Service
+ * Orchestrates authentication operations using composition
+ */
+import type { Auth } from "firebase/auth";
+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 { AuthCoreService } from "./AuthCoreService";
+import { GuestModeService, type IStorageProvider } from "./GuestModeService";
+export declare class AuthService implements IAuthService {
+    private coreService;
+    private guestModeService;
+    private storageProvider?;
+    private initialized;
+    constructor(config?: Partial<AuthConfig>, storageProvider?: IStorageProvider);
+    initialize(providerOrAuth: IAuthProvider | Auth): Promise<void>;
+    isInitialized(): boolean;
+    signUp(params: SignUpParams): Promise<AuthUser>;
+    signIn(params: SignInParams): Promise<AuthUser>;
+    signOut(): Promise<void>;
+    setGuestMode(): Promise<void>;
+    getCurrentUser(): AuthUser | null;
+    getIsGuestMode(): boolean;
+    onAuthStateChange(callback: (user: AuthUser | null) => void): () => void;
+    getConfig(): AuthConfig;
+    getCoreService(): AuthCoreService;
+    getGuestModeService(): GuestModeService;
+}
+/**
+ * Initialize auth service with provider or Firebase Auth instance
+ */
+export declare function initializeAuthService(providerOrAuth: IAuthProvider | Auth, config?: Partial<AuthConfig>, storageProvider?: IStorageProvider): Promise<AuthService>;
+/**
+ * Get auth service instance
+ */
+export declare function getAuthService(): AuthService | null;
+/**
+ * Reset auth service (useful for testing)
+ */
+export declare function resetAuthService(): void;