@umituz/web-firebase 2.0.1 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/web-firebase",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "Comprehensive Firebase integration with DDD architecture for web applications",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/presentation/hooks/useAuth.ts

@@ -1,146 +1,100 @@
 /**
  * Auth Hook
  * @description React hook for authentication operations
- * Migrated from: /Users/umituz/Desktop/github/umituz/apps/web/app-growth-factory/src/domains/firebase/hooks/useAuth.ts
- * Refactored to use use cases
+ * Uses FirebaseProvider context - no repository injection needed
  */
 
-import { useEffect, useState, useCallback } from 'react'
-import { User as FirebaseUser } from 'firebase/auth'
+import { useCallback } from 'react'
+import type { User as FirebaseUser } from 'firebase/auth'
 import type { User } from '../../domain/entities/user.entity'
-import type { IAuthRepository } from '../../domain/interfaces/auth.repository.interface'
-import type { IUserRepository } from '../../domain/interfaces/user.repository.interface'
-import type { SignInDTO, SignUpDTO } from '../../application/dto/auth.dto'
-
-export interface UseAuthOptions {
-  authRepository: IAuthRepository
-  userRepository: IUserRepository
+import { AuthAdapter } from '../../infrastructure/firebase/auth.adapter'
+import { FirestoreAdapter } from '../../infrastructure/firebase/firestore.adapter'
+import { useFirebaseContext } from '../providers/FirebaseProvider'
+
+export interface UseAuthResult {
+  firebaseUser: FirebaseUser | null
+  user: User | null
+  loading: boolean
+  error: Error | null
+  isAuthenticated: boolean
+  isEmailVerified: boolean
+  signIn: (email: string, password: string) => Promise<FirebaseUser>
+  signUp: (email: string, password: string, displayName: string) => Promise<FirebaseUser>
+  signInWithGoogle: () => Promise<FirebaseUser>
+  signOut: () => Promise<void>
+  sendPasswordReset: (email: string) => Promise<void>
+  resendEmailVerification: () => Promise<void>
+  updateProfile: (updates: { displayName?: string; photoURL?: string }) => Promise<void>
+  refreshUser: () => Promise<void>
 }
 
-export function useAuth({ authRepository, userRepository }: UseAuthOptions) {
-  const [firebaseUser, setFirebaseUser] = useState<FirebaseUser | null>(null)
-  const [user, setUser] = useState<User | null>(null)
-  const [loading, setLoading] = useState(true)
-  const [error, setError] = useState<Error | null>(null)
-
-  useEffect(() => {
-    const unsubscribe = authRepository.onAuthStateChanged(async (fbUser) => {
-      setFirebaseUser(fbUser)
-
-      if (fbUser) {
-        try {
-          const userData = await userRepository.getUser(fbUser.uid)
-          setUser(userData)
-        } catch (err) {
-          console.error('Error fetching user data:', err)
-          setError(err as Error)
-        }
-      } else {
-        setUser(null)
-      }
-
-      setLoading(false)
+export function useAuth(): UseAuthResult {
+  const { instances, user, loading, error } = useFirebaseContext()
+
+  const authAdapter = new AuthAdapter()
+  const firestoreAdapter = new FirestoreAdapter()
+
+  const signIn = useCallback(async (email: string, password: string) => {
+    return await authAdapter.signIn(email, password)
+  }, [])
+
+  const signUp = useCallback(async (email: string, password: string, displayName: string) => {
+    const userCredential = await authAdapter.signUp(email, password, displayName)
+
+    // Create user profile in Firestore
+    await firestoreAdapter.createUser(userCredential.user.uid, {
+      profile: {
+        email: email,
+        displayName: displayName,
+        createdAt: Date.now(),
+      },
+      settings: {
+        theme: 'light',
+        language: 'tr',
+      },
     })
 
-    return () => unsubscribe()
-  }, [authRepository, userRepository])
-
-  const signIn = useCallback(async (dto: SignInDTO) => {
-    setError(null)
-    try {
-      return await authRepository.signIn(dto.email, dto.password)
-    } catch (err) {
-      setError(err as Error)
-      throw err
-    }
-  }, [authRepository])
-
-  const signUp = useCallback(async (dto: SignUpDTO) => {
-    setError(null)
-    try {
-      return await authRepository.signUp(dto.email, dto.password, dto.displayName)
-    } catch (err) {
-      setError(err as Error)
-      throw err
-    }
-  }, [authRepository])
+    return userCredential.user
+  }, [])
 
   const signInWithGoogle = useCallback(async () => {
-    setError(null)
-    try {
-      return await authRepository.signInWithGoogle()
-    } catch (err) {
-      setError(err as Error)
-      throw err
-    }
-  }, [authRepository])
+    return await authAdapter.signInWithGoogle()
+  }, [])
 
   const signOut = useCallback(async () => {
-    setError(null)
-    try {
-      await authRepository.signOut()
-      setUser(null)
-      setFirebaseUser(null)
-    } catch (err) {
-      setError(err as Error)
-      throw err
-    }
-  }, [authRepository])
+    await authAdapter.signOut()
+  }, [])
 
   const sendPasswordReset = useCallback(async (email: string) => {
-    setError(null)
-    try {
-      await authRepository.sendPasswordReset(email)
-    } catch (err) {
-      setError(err as Error)
-      throw err
-    }
-  }, [authRepository])
+    await authAdapter.sendPasswordReset(email)
+  }, [])
 
   const resendEmailVerification = useCallback(async () => {
-    setError(null)
-    try {
-      await authRepository.resendEmailVerification()
-    } catch (err) {
-      setError(err as Error)
-      throw err
-    }
-  }, [authRepository])
+    await authAdapter.resendEmailVerification()
+  }, [])
 
   const updateProfile = useCallback(async (updates: { displayName?: string; photoURL?: string }) => {
-    setError(null)
-    try {
-      await authRepository.updateProfile(updates)
-      if (firebaseUser) {
-        const userData = await userRepository.getUser(firebaseUser.uid)
-        setUser(userData)
-      }
-    } catch (err) {
-      setError(err as Error)
-      throw err
+    await authAdapter.updateProfile(updates)
+
+    // Refresh user data from Firestore if available
+    if (instances?.auth.currentUser) {
+      await firestoreAdapter.getUser(instances.auth.currentUser.uid)
     }
-  }, [authRepository, userRepository, firebaseUser])
+  }, [instances])
 
   const refreshUser = useCallback(async () => {
-    setError(null)
-    try {
-      if (firebaseUser) {
-        const userData = await userRepository.getUser(firebaseUser.uid)
-        setUser(userData)
-      }
-    } catch (err) {
-      setError(err as Error)
-      throw err
+    if (instances?.auth.currentUser) {
+      await firestoreAdapter.getUser(instances.auth.currentUser.uid)
     }
-  }, [userRepository, firebaseUser])
+  }, [instances])
 
   return {
-    firebaseUser,
+    firebaseUser: instances?.auth.currentUser || null,
     user,
     loading,
     error,
-    isAuthenticated: !!firebaseUser,
-    isEmailVerified: firebaseUser?.emailVerified || false,
+    isAuthenticated: !!instances?.auth.currentUser,
+    isEmailVerified: instances?.auth.currentUser?.emailVerified || false,
     signIn,
     signUp,
     signInWithGoogle,
@@ -151,3 +105,4 @@ export function useAuth({ authRepository, userRepository }: UseAuthOptions) {
     refreshUser,
   }
 }
+

package/src/presentation/providers/FirebaseProvider.tsx

@@ -1,40 +1,95 @@
 /**
  * FirebaseProvider
- * @description React Context Provider for Firebase initialization
+ * @description React Context Provider for Firebase with auth state tracking
  */
 
-import { createContext, useContext, type ReactNode } from 'react'
+import { createContext, useContext, useState, useEffect, type ReactNode } from 'react'
+import type { User } from 'firebase/auth'
 import type { FirebaseInstances } from '../../infrastructure/firebase/client'
 import { getFirebaseInstances } from '../../infrastructure/firebase/client'
+import { AuthAdapter } from '../../infrastructure/firebase/auth.adapter'
 
-interface FirebaseContextValue {
+export interface FirebaseContextValue {
   instances: FirebaseInstances
   isInitialized: boolean
+  user: User | null
+  loading: boolean
+  error: Error | null
 }
 
 const FirebaseContext = createContext<FirebaseContextValue | null>(null)
 
 export interface FirebaseProviderProps {
   children: ReactNode
+  config?: {
+    apiKey: string
+    authDomain: string
+    projectId: string
+    storageBucket: string
+    messagingSenderId: string
+    appId: string
+  }
 }
 
-export function FirebaseProvider({ children }: FirebaseProviderProps) {
-  // Note: Firebase is already initialized via environment variables
-  // This provider just makes instances available via context
-  const instances = getFirebaseInstances()
+export function FirebaseProvider({ children, config }: FirebaseProviderProps) {
+  const [instances, setInstances] = useState<FirebaseInstances | null>(null)
+  const [user, setUser] = useState<User | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<Error | null>(null)
+
+  useEffect(() => {
+    try {
+      // Initialize Firebase (singleton - won't re-initialize)
+      const firebaseInstances = getFirebaseInstances()
+      setInstances(firebaseInstances)
+
+      // Set up auth state listener
+      const authAdapter = new AuthAdapter()
+      const unsubscribe = authAdapter.onAuthStateChanged(
+        (user) => {
+          setUser(user)
+          setLoading(false)
+          setError(null)
+        },
+        (err) => {
+          setError(err)
+          setLoading(false)
+        }
+      )
+
+      return () => {
+        if (unsubscribe) unsubscribe()
+      }
+    } catch (err) {
+      setError(err as Error)
+      setLoading(false)
+    }
+  }, [config])
 
   const value: FirebaseContextValue = {
-    instances,
-    isInitialized: true,
+    instances: instances!,
+    isInitialized: !!instances,
+    user,
+    loading,
+    error,
+  }
+
+  if (!instances || loading) {
+    return (
+      <FirebaseContext.Provider value={{ ...value, isInitialized: false }}>
+        {children}
+      </FirebaseContext.Provider>
+    )
   }
 
   return <FirebaseContext.Provider value={value}>{children}</FirebaseContext.Provider>
 }
 
-export function useFirebaseContext() {
+export function useFirebaseContext(): FirebaseContextValue {
   const context = useContext(FirebaseContext)
   if (!context) {
     throw new Error('useFirebaseContext must be used within FirebaseProvider')
   }
   return context
 }
+