@umituz/react-native-auth 2.0.1 → 2.2.0

package/lib/infrastructure/services/AuthService.js

@@ -1,123 +0,0 @@
-/**
- * Auth Service
- * Orchestrates authentication operations using composition
- */
-import { DEFAULT_AUTH_CONFIG } from "../../domain/value-objects/AuthConfig";
-import { AuthCoreService } from "./AuthCoreService";
-import { GuestModeService } from "./GuestModeService";
-import { authEventService } from "./AuthEventService";
-import { getAuthPackage } from "./AuthPackage";
-export class AuthService {
-    constructor(config = {}, storageProvider) {
-        this.initialized = false;
-        const authConfig = {
-            ...DEFAULT_AUTH_CONFIG,
-            ...config,
-            password: {
-                ...DEFAULT_AUTH_CONFIG.password,
-                ...config.password,
-            },
-        };
-        this.coreService = new AuthCoreService(authConfig);
-        this.guestModeService = new GuestModeService();
-        this.storageProvider = storageProvider;
-    }
-    async initialize(providerOrAuth) {
-        if (this.initialized) {
-            return;
-        }
-        // 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.initialized = true;
-    }
-    isInitialized() {
-        return this.initialized && this.coreService.isInitialized();
-    }
-    async signUp(params) {
-        const user = await this.coreService.signUp(params);
-        // Clear guest mode when user signs up
-        if (this.guestModeService.getIsGuestMode() && this.storageProvider) {
-            await this.guestModeService.clear(this.storageProvider);
-        }
-        authEventService.emitUserAuthenticated(user.uid);
-        return user;
-    }
-    async signIn(params) {
-        const user = await this.coreService.signIn(params);
-        // Clear guest mode when user signs in
-        if (this.guestModeService.getIsGuestMode() && this.storageProvider) {
-            await this.guestModeService.clear(this.storageProvider);
-        }
-        authEventService.emitUserAuthenticated(user.uid);
-        return user;
-    }
-    async signOut() {
-        await this.coreService.signOut();
-        // Clear guest mode if signing out explicitly
-        if (this.guestModeService.getIsGuestMode() && this.storageProvider) {
-            await this.guestModeService.clear(this.storageProvider);
-        }
-    }
-    async setGuestMode() {
-        if (!this.storageProvider) {
-            throw new Error("Storage provider is required for guest mode");
-        }
-        // No provider needed for guest mode enablement
-        await this.guestModeService.enable(this.storageProvider);
-    }
-    getCurrentUser() {
-        if (this.guestModeService.getIsGuestMode()) {
-            return null;
-        }
-        return this.coreService.getCurrentUser();
-    }
-    getIsGuestMode() {
-        return this.guestModeService.getIsGuestMode();
-    }
-    onAuthStateChange(callback) {
-        const wrappedCallback = this.guestModeService.wrapAuthStateCallback(callback);
-        return this.coreService.onAuthStateChange(wrappedCallback);
-    }
-    getConfig() {
-        return this.coreService.getConfig();
-    }
-    getCoreService() {
-        return this.coreService;
-    }
-    getGuestModeService() {
-        return this.guestModeService;
-    }
-}
-// Singleton instance
-let authServiceInstance = null;
-/**
- * Initialize auth service with provider or Firebase Auth instance
- */
-export async function initializeAuthService(providerOrAuth, config, storageProvider) {
-    if (!authServiceInstance) {
-        // Initialize package if not already done
-        const packageConfig = getAuthPackage()?.getConfig();
-        authServiceInstance = new AuthService(config, storageProvider);
-    }
-    await authServiceInstance.initialize(providerOrAuth);
-    return authServiceInstance;
-}
-/**
- * Get auth service instance
- */
-export function getAuthService() {
-    if (!authServiceInstance || !authServiceInstance.isInitialized()) {
-        return null;
-    }
-    return authServiceInstance;
-}
-/**
- * Reset auth service (useful for testing)
- */
-export function resetAuthService() {
-    authServiceInstance = null;
-}

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

@@ -1,23 +0,0 @@
-/**
- * Guest Mode Service
- * Handles guest mode functionality
- */
-import type { IAuthProvider } from "../../application/ports/IAuthProvider";
-import type { AuthUser } from "../../domain/entities/AuthUser";
-export interface IStorageProvider {
-    get(key: string): Promise<string | null>;
-    set(key: string, value: string): Promise<void>;
-    remove(key: string): Promise<void>;
-}
-export declare class GuestModeService {
-    private isGuestMode;
-    private storageKey;
-    constructor(storageKey?: string);
-    load(storageProvider: IStorageProvider): Promise<boolean>;
-    save(storageProvider: IStorageProvider): Promise<void>;
-    clear(storageProvider: IStorageProvider): Promise<void>;
-    enable(storageProvider: IStorageProvider, provider?: IAuthProvider): Promise<void>;
-    getIsGuestMode(): boolean;
-    setGuestMode(enabled: boolean): void;
-    wrapAuthStateCallback(callback: (user: AuthUser | null) => void): (user: AuthUser | null) => void;
-}

package/lib/infrastructure/services/GuestModeService.js

@@ -1,69 +0,0 @@
-/**
- * Guest Mode Service
- * Handles guest mode functionality
- */
-import { emitGuestModeEnabled } from "../utils/AuthEventEmitter";
-export class GuestModeService {
-    constructor(storageKey = "@auth_guest_mode") {
-        this.isGuestMode = false;
-        this.storageKey = storageKey;
-    }
-    async load(storageProvider) {
-        try {
-            const value = await storageProvider.get(this.storageKey);
-            this.isGuestMode = value === "true";
-            return this.isGuestMode;
-        }
-        catch {
-            return false;
-        }
-    }
-    async save(storageProvider) {
-        try {
-            await storageProvider.set(this.storageKey, this.isGuestMode.toString());
-        }
-        catch {
-            // Silently fail storage operations
-        }
-    }
-    async clear(storageProvider) {
-        try {
-            await storageProvider.remove(this.storageKey);
-        }
-        catch {
-            // Silently fail storage operations
-        }
-        this.isGuestMode = false;
-    }
-    async enable(storageProvider, provider) {
-        // Sign out from provider if logged in
-        if (provider?.getCurrentUser()) {
-            try {
-                await provider.signOut();
-            }
-            catch {
-                // Ignore sign out errors when switching to guest mode
-            }
-        }
-        this.isGuestMode = true;
-        await this.save(storageProvider);
-        emitGuestModeEnabled();
-    }
-    getIsGuestMode() {
-        return this.isGuestMode;
-    }
-    setGuestMode(enabled) {
-        this.isGuestMode = enabled;
-    }
-    wrapAuthStateCallback(callback) {
-        return (user) => {
-            // Don't update if in guest mode
-            if (!this.isGuestMode) {
-                callback(user);
-            }
-            else {
-                callback(null);
-            }
-        };
-    }
-}

package/lib/infrastructure/storage/GuestModeStorage.d.ts

@@ -1,16 +0,0 @@
-/**
- * Guest Mode Storage
- * Single Responsibility: Manage guest mode persistence
- */
-/**
- * Load guest mode from storage
- */
-export declare function loadGuestMode(storageKey?: string): Promise<boolean>;
-/**
- * Save guest mode to storage
- */
-export declare function saveGuestMode(isGuest: boolean, storageKey?: string): Promise<void>;
-/**
- * Clear guest mode from storage
- */
-export declare function clearGuestMode(storageKey?: string): Promise<void>;

package/lib/infrastructure/storage/GuestModeStorage.js

@@ -1,73 +0,0 @@
-/**
- * Guest Mode Storage
- * Single Responsibility: Manage guest mode persistence
- */
-import { getAuthPackage } from "../services/AuthPackage";
-/**
- * Load guest mode from storage
- */
-export async function loadGuestMode(storageKey) {
-    try {
-        const packageConfig = getAuthPackage()?.getConfig();
-        const key = storageKey ?? packageConfig?.storageKeys.guestMode ?? "@auth_guest_mode";
-        const storageProvider = getAuthPackage()?.getStorageProvider();
-        if (!storageProvider) {
-            if (__DEV__) {
-                console.warn("[GuestModeStorage] No storage provider available");
-            }
-            return false;
-        }
-        const value = await storageProvider.get(key);
-        return value === "true";
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Save guest mode to storage
- */
-export async function saveGuestMode(isGuest, storageKey) {
-    try {
-        const packageConfig = getAuthPackage()?.getConfig();
-        const key = storageKey ?? packageConfig?.storageKeys.guestMode ?? "@auth_guest_mode";
-        const storageProvider = getAuthPackage()?.getStorageProvider();
-        if (!storageProvider) {
-            if (__DEV__) {
-                console.warn("[GuestModeStorage] No storage provider available");
-            }
-            return;
-        }
-        if (isGuest) {
-            await storageProvider.set(key, "true");
-            if (__DEV__) {
-                console.log("[GuestModeStorage] Guest mode persisted to storage");
-            }
-        }
-        else {
-            await storageProvider.remove(key);
-        }
-    }
-    catch (error) {
-        if (__DEV__) {
-            console.warn("[GuestModeStorage] Failed to persist guest mode:", error);
-        }
-    }
-}
-/**
- * Clear guest mode from storage
- */
-export async function clearGuestMode(storageKey) {
-    try {
-        const packageConfig = getAuthPackage()?.getConfig();
-        const key = storageKey ?? packageConfig?.storageKeys.guestMode ?? "@auth_guest_mode";
-        const storageProvider = getAuthPackage()?.getStorageProvider();
-        if (!storageProvider) {
-            return;
-        }
-        await storageProvider.remove(key);
-    }
-    catch {
-        // Ignore storage errors
-    }
-}

package/lib/infrastructure/utils/AuthErrorMapper.d.ts

@@ -1,8 +0,0 @@
-/**
- * Auth Error Mapper
- * Single Responsibility: Map Firebase Auth errors to domain errors
- */
-/**
- * Map Firebase Auth errors to domain errors
- */
-export declare function mapFirebaseAuthError(error: unknown): Error;

package/lib/infrastructure/utils/AuthErrorMapper.js

@@ -1,51 +0,0 @@
-/**
- * Auth Error Mapper
- * Single Responsibility: Map Firebase Auth errors to domain errors
- */
-import { AuthError, AuthConfigurationError, AuthEmailAlreadyInUseError, AuthInvalidEmailError, AuthWeakPasswordError, AuthUserNotFoundError, AuthWrongPasswordError, AuthNetworkError, } from "../../domain/errors/AuthError";
-/**
- * Map Firebase Auth errors to domain errors
- */
-export function mapFirebaseAuthError(error) {
-    if (!error || typeof error !== 'object') {
-        return new AuthError("Authentication failed", "AUTH_UNKNOWN_ERROR");
-    }
-    const errorObj = error;
-    const code = errorObj.code || "";
-    const message = errorObj.message || "Authentication failed";
-    switch (code) {
-        case "auth/email-already-in-use":
-            return new AuthEmailAlreadyInUseError();
-        case "auth/invalid-email":
-            return new AuthInvalidEmailError();
-        case "auth/weak-password":
-            return new AuthWeakPasswordError();
-        case "auth/user-disabled":
-            return new AuthError("Your account has been disabled. Please contact support.", "AUTH_USER_DISABLED");
-        case "auth/user-not-found":
-            return new AuthUserNotFoundError();
-        case "auth/wrong-password":
-            return new AuthWrongPasswordError();
-        case "auth/invalid-credential":
-            return new AuthError("Invalid email or password. Please check your credentials.", "AUTH_INVALID_CREDENTIAL");
-        case "auth/invalid-login-credentials":
-            return new AuthError("Invalid email or password. Please check your credentials.", "AUTH_INVALID_CREDENTIAL");
-        case "auth/network-request-failed":
-            return new AuthNetworkError();
-        case "auth/too-many-requests":
-            return new AuthError("Too many failed attempts. Please wait a few minutes and try again.", "AUTH_TOO_MANY_REQUESTS");
-        case "auth/configuration-not-found":
-        case "auth/app-not-authorized":
-            return new AuthConfigurationError("Authentication is not properly configured. Please contact support.");
-        case "auth/operation-not-allowed":
-            return new AuthConfigurationError("Email/password authentication is not enabled. Please contact support.");
-        case "auth/requires-recent-login":
-            return new AuthError("Please sign in again to complete this action.", "AUTH_REQUIRES_RECENT_LOGIN");
-        case "auth/expired-action-code":
-            return new AuthError("This link has expired. Please request a new one.", "AUTH_EXPIRED_ACTION_CODE");
-        case "auth/invalid-action-code":
-            return new AuthError("This link is invalid. Please request a new one.", "AUTH_INVALID_ACTION_CODE");
-        default:
-            return new AuthError(message, code || "AUTH_UNKNOWN_ERROR");
-    }
-}

package/lib/infrastructure/utils/AuthEventEmitter.d.ts

@@ -1,12 +0,0 @@
-/**
- * Auth Event Emitter
- * Single Responsibility: Emit auth-related events
- */
-/**
- * Emit user authenticated event
- */
-export declare function emitUserAuthenticated(userId: string): void;
-/**
- * Emit guest mode enabled event
- */
-export declare function emitGuestModeEnabled(): void;

package/lib/infrastructure/utils/AuthEventEmitter.js

@@ -1,25 +0,0 @@
-/**
- * Auth Event Emitter
- * Single Responsibility: Emit auth-related events
- */
-import { DeviceEventEmitter } from "react-native";
-/**
- * Emit user authenticated event
- */
-export function emitUserAuthenticated(userId) {
-    /* eslint-disable-next-line no-console */
-    if (__DEV__) {
-        console.log("[AuthEventEmitter] Emitting user-authenticated event");
-    }
-    DeviceEventEmitter.emit("user-authenticated", { userId });
-}
-/**
- * Emit guest mode enabled event
- */
-export function emitGuestModeEnabled() {
-    /* eslint-disable-next-line no-console */
-    if (__DEV__) {
-        console.log("[AuthEventEmitter] Emitting guest-mode-enabled event");
-    }
-    DeviceEventEmitter.emit("guest-mode-enabled");
-}

package/lib/infrastructure/utils/AuthValidation.d.ts

@@ -1,49 +0,0 @@
-/**
- * Auth Validation Utilities
- * Single Responsibility: Email and password validation for authentication
- */
-import type { PasswordConfig } from "../../domain/value-objects/AuthConfig";
-export interface ValidationResult {
-    isValid: boolean;
-    error?: string;
-}
-export interface PasswordStrengthResult extends ValidationResult {
-    requirements: PasswordRequirements;
-}
-export interface PasswordRequirements {
-    hasMinLength: boolean;
-    hasUppercase: boolean;
-    hasLowercase: boolean;
-    hasNumber: boolean;
-    hasSpecialChar: boolean;
-}
-export interface ValidationConfig {
-    emailRegex: RegExp;
-    uppercaseRegex: RegExp;
-    lowercaseRegex: RegExp;
-    numberRegex: RegExp;
-    specialCharRegex: RegExp;
-    displayNameMinLength: number;
-}
-/**
- * Validate email format
- */
-export declare function validateEmail(email: string): ValidationResult;
-/**
- * Validate password for login - only checks if password is provided
- * No strength requirements for login (existing users may have old passwords)
- */
-export declare function validatePasswordForLogin(password: string): ValidationResult;
-/**
- * Validate password strength for registration
- * Returns detailed requirements for UI feedback
- */
-export declare function validatePasswordForRegister(password: string, config: PasswordConfig): PasswordStrengthResult;
-/**
- * Validate password confirmation
- */
-export declare function validatePasswordConfirmation(password: string, confirmPassword: string): ValidationResult;
-/**
- * Validate display name
- */
-export declare function validateDisplayName(displayName: string, minLength?: number): ValidationResult;

package/lib/infrastructure/utils/AuthValidation.js

@@ -1,133 +0,0 @@
-/**
- * Auth Validation Utilities
- * Single Responsibility: Email and password validation for authentication
- */
-import { getAuthPackage } from "../services/AuthPackage";
-const DEFAULT_VALIDATION_CONFIG = {
-    emailRegex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
-    uppercaseRegex: /[A-Z]/,
-    lowercaseRegex: /[a-z]/,
-    numberRegex: /[0-9]/,
-    specialCharRegex: /[!@#$%^&*(),.?":{}|<>]/,
-    displayNameMinLength: 2,
-};
-function getValidationConfig() {
-    const packageConfig = getAuthPackage()?.getConfig();
-    return {
-        emailRegex: packageConfig?.validation.emailRegex || DEFAULT_VALIDATION_CONFIG.emailRegex,
-        uppercaseRegex: DEFAULT_VALIDATION_CONFIG.uppercaseRegex,
-        lowercaseRegex: DEFAULT_VALIDATION_CONFIG.lowercaseRegex,
-        numberRegex: DEFAULT_VALIDATION_CONFIG.numberRegex,
-        specialCharRegex: DEFAULT_VALIDATION_CONFIG.specialCharRegex,
-        displayNameMinLength: DEFAULT_VALIDATION_CONFIG.displayNameMinLength,
-    };
-}
-/**
- * Validate email format
- */
-export function validateEmail(email) {
-    if (!email || email.trim() === "") {
-        return { isValid: false, error: "Email is required" };
-    }
-    const config = getValidationConfig();
-    if (!config.emailRegex.test(email.trim())) {
-        return { isValid: false, error: "Please enter a valid email address" };
-    }
-    return { isValid: true };
-}
-/**
- * Validate password for login - only checks if password is provided
- * No strength requirements for login (existing users may have old passwords)
- */
-export function validatePasswordForLogin(password) {
-    if (!password || password.length === 0) {
-        return { isValid: false, error: "Password is required" };
-    }
-    return { isValid: true };
-}
-/**
- * Validate password strength for registration
- * Returns detailed requirements for UI feedback
- */
-export function validatePasswordForRegister(password, config) {
-    const validationConfig = getValidationConfig();
-    const requirements = {
-        hasMinLength: password.length >= config.minLength,
-        hasUppercase: !config.requireUppercase || validationConfig.uppercaseRegex.test(password),
-        hasLowercase: !config.requireLowercase || validationConfig.lowercaseRegex.test(password),
-        hasNumber: !config.requireNumber || validationConfig.numberRegex.test(password),
-        hasSpecialChar: !config.requireSpecialChar || validationConfig.specialCharRegex.test(password),
-    };
-    if (!password || password.length === 0) {
-        return {
-            isValid: false,
-            error: "Password is required",
-            requirements,
-        };
-    }
-    if (!requirements.hasMinLength) {
-        return {
-            isValid: false,
-            error: `Password must be at least ${config.minLength} characters`,
-            requirements,
-        };
-    }
-    if (config.requireUppercase && !validationConfig.uppercaseRegex.test(password)) {
-        return {
-            isValid: false,
-            error: "Password must contain at least one uppercase letter",
-            requirements,
-        };
-    }
-    if (config.requireLowercase && !validationConfig.lowercaseRegex.test(password)) {
-        return {
-            isValid: false,
-            error: "Password must contain at least one lowercase letter",
-            requirements,
-        };
-    }
-    if (config.requireNumber && !validationConfig.numberRegex.test(password)) {
-        return {
-            isValid: false,
-            error: "Password must contain at least one number",
-            requirements,
-        };
-    }
-    if (config.requireSpecialChar && !validationConfig.specialCharRegex.test(password)) {
-        return {
-            isValid: false,
-            error: "Password must contain at least one special character",
-            requirements,
-        };
-    }
-    return { isValid: true, requirements };
-}
-/**
- * Validate password confirmation
- */
-export function validatePasswordConfirmation(password, confirmPassword) {
-    if (!confirmPassword) {
-        return { isValid: false, error: "Please confirm your password" };
-    }
-    if (password !== confirmPassword) {
-        return { isValid: false, error: "Passwords do not match" };
-    }
-    return { isValid: true };
-}
-/**
- * Validate display name
- */
-export function validateDisplayName(displayName, minLength) {
-    if (!displayName || displayName.trim() === "") {
-        return { isValid: false, error: "Name is required" };
-    }
-    const config = getValidationConfig();
-    const actualMinLength = minLength ?? config.displayNameMinLength;
-    if (displayName.trim().length < actualMinLength) {
-        return {
-            isValid: false,
-            error: `Name must be at least ${actualMinLength} characters`,
-        };
-    }
-    return { isValid: true };
-}

package/lib/infrastructure/utils/UserMapper.d.ts

@@ -1,15 +0,0 @@
-/**
- * User Mapper
- * Single Source of Truth for user object transformations
- */
-import type { AuthUser } from "../../domain/entities/AuthUser";
-interface FirebaseUserLike {
-    uid: string;
-    email: string | null;
-    displayName: string | null;
-    isAnonymous: boolean;
-    emailVerified: boolean;
-    photoURL: string | null;
-}
-export declare function mapToAuthUser(user: FirebaseUserLike | null): AuthUser | null;
-export {};

package/lib/infrastructure/utils/UserMapper.js

@@ -1,16 +0,0 @@
-/**
- * User Mapper
- * Single Source of Truth for user object transformations
- */
-export function mapToAuthUser(user) {
-    if (!user)
-        return null;
-    return {
-        uid: user.uid,
-        email: user.email,
-        displayName: user.displayName,
-        isAnonymous: user.isAnonymous,
-        emailVerified: user.emailVerified,
-        photoURL: user.photoURL,
-    };
-}

package/lib/presentation/components/AuthContainer.d.ts

@@ -1,10 +0,0 @@
-/**
- * Auth Container Component
- * Main container for auth screens with gradient and scroll
- */
-import React from "react";
-interface AuthContainerProps {
-    children: React.ReactNode;
-}
-export declare const AuthContainer: React.FC<AuthContainerProps>;
-export {};

package/lib/presentation/components/AuthContainer.js

@@ -1,27 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { View, StyleSheet, ScrollView, KeyboardAvoidingView, Platform, } from "react-native";
-import { useSafeAreaInsets } from "react-native-safe-area-context";
-import { AuthGradientBackground } from "./AuthGradientBackground";
-export const AuthContainer = ({ children }) => {
-    const insets = useSafeAreaInsets();
-    return (_jsxs(KeyboardAvoidingView, { style: styles.container, behavior: Platform.OS === "ios" ? "padding" : "height", keyboardVerticalOffset: Platform.OS === "ios" ? 0 : 20, children: [_jsx(AuthGradientBackground, {}), _jsx(ScrollView, { contentContainerStyle: [
-                    styles.scrollContent,
-                    { paddingTop: insets.top + 40, paddingBottom: insets.bottom + 40 },
-                ], keyboardShouldPersistTaps: "handled", showsVerticalScrollIndicator: false, children: _jsx(View, { style: styles.content, children: children }) })] }));
-};
-const styles = StyleSheet.create({
-    container: {
-        flex: 1,
-    },
-    scrollContent: {
-        flexGrow: 1,
-        paddingHorizontal: 20,
-    },
-    content: {
-        flex: 1,
-        justifyContent: "center",
-        maxWidth: 440,
-        alignSelf: "center",
-        width: "100%",
-    },
-});

package/lib/presentation/components/AuthDivider.d.ts

@@ -1,6 +0,0 @@
-/**
- * Auth Divider Component
- * Divider with "OR" text for auth screens
- */
-import React from "react";
-export declare const AuthDivider: React.FC;