@umituz/react-native-auth 3.1.8 → 3.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.1.8",
+  "version": "3.1.10",
   "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": "./src/index.ts",
   "types": "./src/index.ts",

package/src/index.ts

@@ -105,6 +105,12 @@ export type {
   PasswordRequirements,
 } from './infrastructure/utils/AuthValidation';
 
+// =============================================================================
+// PRESENTATION LAYER - Provider
+// =============================================================================
+
+export { AuthProvider } from './presentation/providers/AuthProvider';
+
 // =============================================================================
 // PRESENTATION LAYER - Hooks
 // =============================================================================
@@ -112,6 +118,11 @@ export type {
 export { useAuth } from './presentation/hooks/useAuth';
 export type { UseAuthResult } from './presentation/hooks/useAuth';
 
+export { useAuthRequired } from './presentation/hooks/useAuthRequired';
+export type { UseAuthRequiredResult } from './presentation/hooks/useAuthRequired';
+
+export { useRequireAuth, useUserId } from './presentation/hooks/useRequireAuth';
+
 export { useUserProfile } from './presentation/hooks/useUserProfile';
 export type { UserProfileData, UseUserProfileParams } from './presentation/hooks/useUserProfile';
 
@@ -183,8 +194,19 @@ export {
   initializeAuthListener,
   resetAuthListener,
   selectIsAuthenticated,
+  selectUserId,
+  selectIsAnonymous,
+  selectUserType,
+  selectIsAuthReady,
+  getUserId,
+  getUserType,
+  getIsAuthenticated,
+  getIsGuest,
+  getIsAnonymous,
 } from './presentation/stores/authStore';
 
+export type { UserType } from './presentation/stores/authStore';
+
 // =============================================================================
 // PRESENTATION LAYER - Utilities
 // =============================================================================

package/src/presentation/hooks/useAuth.ts

@@ -4,15 +4,18 @@
  *
  * Uses centralized Zustand store for auth state.
  * Single source of truth - no duplicate subscriptions.
- *
- * @example
- * ```typescript
- * const { user, isAuthenticated, signIn, signUp, signOut } = useAuth();
- * ```
  */
 
 import { useCallback } from "react";
-import { useAuthStore, selectIsAuthenticated } from "../stores/authStore";
+import {
+  useAuthStore,
+  selectIsAuthenticated,
+  selectUserId,
+  selectUserType,
+  selectIsAnonymous,
+  selectIsAuthReady,
+  type UserType,
+} from "../stores/authStore";
 import {
   useSignInMutation,
   useSignUpMutation,
@@ -24,11 +27,19 @@ import type { AuthUser } from "../../domain/entities/AuthUser";
 export interface UseAuthResult {
   /** Current authenticated user */
   user: AuthUser | null;
+  /** Current user ID (uid) */
+  userId: string | null;
+  /** Current user type */
+  userType: UserType;
   /** Whether auth state is loading */
   loading: boolean;
+  /** Whether auth is ready (initialized and not loading) */
+  isAuthReady: boolean;
   /** Whether user is in guest mode */
   isGuest: boolean;
-  /** Whether user is authenticated */
+  /** Whether user is anonymous */
+  isAnonymous: boolean;
+  /** Whether user is authenticated (not guest, not anonymous) */
   isAuthenticated: boolean;
   /** Current error message */
   error: string | null;
@@ -49,11 +60,6 @@ export interface UseAuthResult {
  *
  * Uses centralized Zustand store - all components share the same state.
  * Must call initializeAuthListener() once in app root.
- *
- * @example
- * ```typescript
- * const { user, isAuthenticated, signIn, signUp, signOut } = useAuth();
- * ```
  */
 export function useAuth(): UseAuthResult {
   // State from store
@@ -62,6 +68,10 @@ export function useAuth(): UseAuthResult {
   const isGuest = useAuthStore((state) => state.isGuest);
   const error = useAuthStore((state) => state.error);
   const isAuthenticated = useAuthStore(selectIsAuthenticated);
+  const userId = useAuthStore(selectUserId);
+  const userType = useAuthStore(selectUserType);
+  const isAnonymous = useAuthStore(selectIsAnonymous);
+  const isAuthReady = useAuthStore(selectIsAuthReady);
 
   // Actions from store
   const setLoading = useAuthStore((state) => state.setLoading);
@@ -137,8 +147,12 @@ export function useAuth(): UseAuthResult {
 
   return {
     user,
+    userId,
+    userType,
     loading,
+    isAuthReady,
     isGuest,
+    isAnonymous,
     isAuthenticated,
     error,
     signUp,

package/src/presentation/hooks/useAuthRequired.ts

@@ -0,0 +1,69 @@
+/**
+ * useAuthRequired Hook
+ * Check if user meets auth requirements for a feature
+ *
+ * Usage:
+ * ```tsx
+ * const { isAllowed, requireAuth } = useAuthRequired();
+ *
+ * const handleAction = () => {
+ *   if (!isAllowed) {
+ *     requireAuth(); // Opens auth modal
+ *     return;
+ *   }
+ *   // Proceed with action
+ * };
+ * ```
+ */
+
+import { useCallback } from "react";
+import { useAuthStore, selectIsAuthenticated } from "../stores/authStore";
+import { useAuthModalStore } from "../stores/authModalStore";
+
+export interface UseAuthRequiredResult {
+  /** Whether user is authenticated (not guest, not anonymous) */
+  isAllowed: boolean;
+  /** Whether auth is still loading */
+  isLoading: boolean;
+  /** Current user ID (null if not authenticated) */
+  userId: string | null;
+  /** Show auth modal to require authentication */
+  requireAuth: () => void;
+  /** Check and require auth - returns true if allowed, false if modal shown */
+  checkAndRequireAuth: () => boolean;
+}
+
+/**
+ * Hook to check auth requirements and show modal if needed
+ */
+export function useAuthRequired(): UseAuthRequiredResult {
+  const isAllowed = useAuthStore(selectIsAuthenticated);
+  const isLoading = useAuthStore((state) => state.loading);
+  const userId = useAuthStore((state) => state.firebaseUser?.uid ?? null);
+  const openAuthModal = useAuthModalStore((state) => state.open);
+
+  const requireAuth = useCallback(() => {
+    openAuthModal("login");
+  }, [openAuthModal]);
+
+  const checkAndRequireAuth = useCallback((): boolean => {
+    if (isLoading) {
+      return false;
+    }
+
+    if (!isAllowed) {
+      openAuthModal("login");
+      return false;
+    }
+
+    return true;
+  }, [isAllowed, isLoading, openAuthModal]);
+
+  return {
+    isAllowed,
+    isLoading,
+    userId,
+    requireAuth,
+    checkAndRequireAuth,
+  };
+}

package/src/presentation/hooks/useRequireAuth.ts

@@ -0,0 +1,35 @@
+/**
+ * useRequireAuth Hook
+ * Returns userId, throws if not authenticated
+ *
+ * Usage:
+ * ```tsx
+ * // In a component that MUST have authenticated user
+ * const userId = useRequireAuth();
+ * // userId is guaranteed to be string, not null
+ * ```
+ */
+
+import { useAuthStore, selectIsAuthenticated } from "../stores/authStore";
+
+/**
+ * Get userId or throw if not authenticated
+ * Use this in components that REQUIRE authentication
+ */
+export function useRequireAuth(): string {
+  const isAuthenticated = useAuthStore(selectIsAuthenticated);
+  const userId = useAuthStore((state) => state.firebaseUser?.uid ?? null);
+
+  if (!isAuthenticated || !userId) {
+    throw new Error("User not authenticated. This component requires auth.");
+  }
+
+  return userId;
+}
+
+/**
+ * Get userId safely (returns null if not authenticated)
+ */
+export function useUserId(): string | null {
+  return useAuthStore((state) => state.firebaseUser?.uid ?? null);
+}

package/src/presentation/providers/AuthProvider.tsx

@@ -0,0 +1,32 @@
+/**
+ * AuthProvider
+ * Wraps app and handles auth initialization
+ *
+ * Usage:
+ * ```tsx
+ * <AuthProvider>
+ *   <App />
+ * </AuthProvider>
+ * ```
+ */
+
+import React, { useEffect, type ReactNode } from "react";
+import { initializeAuthListener } from "../stores/authStore";
+
+interface AuthProviderProps {
+  children: ReactNode;
+}
+
+/**
+ * AuthProvider component
+ * Initializes Firebase auth listener on mount
+ * Must wrap the app root
+ */
+export function AuthProvider({ children }: AuthProviderProps): JSX.Element {
+  useEffect(() => {
+    const unsubscribe = initializeAuthListener();
+    return unsubscribe;
+  }, []);
+
+  return <>{children}</>;
+}

package/src/presentation/stores/authStore.ts

@@ -4,18 +4,6 @@
  *
  * Single source of truth for auth state across the app.
  * Firebase auth changes are synced via initializeAuthListener().
- *
- * @example
- * ```typescript
- * // Initialize once in app root
- * useEffect(() => {
- *   const unsubscribe = initializeAuthListener();
- *   return unsubscribe;
- * }, []);
- *
- * // Use anywhere
- * const { user, isAuthenticated, signIn, signOut } = useAuthStore();
- * ```
  */
 
 import { createStore } from "@umituz/react-native-storage";
@@ -25,6 +13,13 @@ import type { AuthUser } from "../../domain/entities/AuthUser";
 import { mapToAuthUser } from "../../infrastructure/utils/UserMapper";
 import { getAuthService } from "../../infrastructure/services/AuthService";
 
+declare const __DEV__: boolean;
+
+/**
+ * User type classification
+ */
+export type UserType = "authenticated" | "anonymous" | "none";
+
 // =============================================================================
 // STATE TYPES
 // =============================================================================
@@ -82,7 +77,6 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
   persist: true,
   version: 1,
   partialize: (state) => ({
-    // Only persist these fields (not functions, not firebaseUser)
     isGuest: state.isGuest,
     initialized: state.initialized,
   }),
@@ -93,12 +87,9 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
       let user: AuthUser | null = null;
 
       if (firebaseUser) {
-        // Non-anonymous users always get mapped
         if (!firebaseUser.isAnonymous) {
           user = mapToAuthUser(firebaseUser);
-        }
-        // Anonymous users only if not in guest mode
-        else if (!isGuest) {
+        } else if (!isGuest) {
           user = mapToAuthUser(firebaseUser);
         }
       }
@@ -115,7 +106,6 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
     setIsGuest: (isGuest) => {
       const { firebaseUser } = get();
 
-      // Recalculate user when guest mode changes
       let user: AuthUser | null = null;
       if (firebaseUser) {
         if (!firebaseUser.isAnonymous) {
@@ -140,6 +130,13 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
 // SELECTORS
 // =============================================================================
 
+/**
+ * Get current user ID
+ */
+export const selectUserId = (state: AuthState): string | null => {
+  return state.firebaseUser?.uid ?? state.user?.uid ?? null;
+};
+
 /**
  * Check if user is authenticated (not guest, not anonymous)
  */
@@ -147,6 +144,73 @@ export const selectIsAuthenticated = (state: AuthState): boolean => {
   return !!state.user && !state.isGuest && !state.user.isAnonymous;
 };
 
+/**
+ * Check if user is anonymous
+ */
+export const selectIsAnonymous = (state: AuthState): boolean => {
+  return state.firebaseUser?.isAnonymous ?? state.user?.isAnonymous ?? false;
+};
+
+/**
+ * Get current user type
+ */
+export const selectUserType = (state: AuthState): UserType => {
+  if (!state.firebaseUser && !state.user) {
+    return "none";
+  }
+
+  const isAnonymous =
+    state.firebaseUser?.isAnonymous ?? state.user?.isAnonymous ?? false;
+
+  return isAnonymous ? "anonymous" : "authenticated";
+};
+
+/**
+ * Check if auth is ready (initialized and not loading)
+ */
+export const selectIsAuthReady = (state: AuthState): boolean => {
+  return state.initialized && !state.loading;
+};
+
+// =============================================================================
+// NON-HOOK GETTERS
+// =============================================================================
+
+/**
+ * Get user ID without hook
+ */
+export function getUserId(): string | null {
+  return selectUserId(useAuthStore.getState());
+}
+
+/**
+ * Get user type without hook
+ */
+export function getUserType(): UserType {
+  return selectUserType(useAuthStore.getState());
+}
+
+/**
+ * Check if authenticated without hook
+ */
+export function getIsAuthenticated(): boolean {
+  return selectIsAuthenticated(useAuthStore.getState());
+}
+
+/**
+ * Check if guest without hook
+ */
+export function getIsGuest(): boolean {
+  return useAuthStore.getState().isGuest;
+}
+
+/**
+ * Check if anonymous without hook
+ */
+export function getIsAnonymous(): boolean {
+  return selectIsAnonymous(useAuthStore.getState());
+}
+
 // =============================================================================
 // LISTENER
 // =============================================================================
@@ -156,17 +220,8 @@ let listenerInitialized = false;
 /**
  * Initialize Firebase auth listener
  * Call once in app root, returns unsubscribe function
- *
- * @example
- * ```typescript
- * useEffect(() => {
- *   const unsubscribe = initializeAuthListener();
- *   return unsubscribe;
- * }, []);
- * ```
  */
 export function initializeAuthListener(): () => void {
-  // Prevent multiple initializations
   if (listenerInitialized) {
     return () => {};
   }
@@ -180,7 +235,6 @@ export function initializeAuthListener(): () => void {
     return () => {};
   }
 
-  // Sync initial guest mode from service
   const service = getAuthService();
   if (service) {
     const isGuest = service.getIsGuestMode();
@@ -191,16 +245,15 @@ export function initializeAuthListener(): () => void {
 
   listenerInitialized = true;
 
-  // Subscribe to auth state changes
   const unsubscribe = onAuthStateChanged(auth, (user) => {
-    if (__DEV__) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
       console.log("[authStore] Auth state changed:", user?.uid ?? "null");
     }
 
     store.setFirebaseUser(user);
     store.setInitialized(true);
 
-    // Reset guest mode when real user signs in
     if (user && !user.isAnonymous && store.isGuest) {
       store.setIsGuest(false);
     }