@umituz/web-firebase 1.0.5 → 2.1.0

package/src/presentation/hooks/useAuth.ts

@@ -0,0 +1,108 @@
+/**
+ * Auth Hook
+ * @description React hook for authentication operations
+ * Uses FirebaseProvider context - no repository injection needed
+ */
+
+import { useCallback } from 'react'
+import type { User as FirebaseUser } from 'firebase/auth'
+import type { User } from '../../domain/entities/user.entity'
+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(): 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 userCredential.user
+  }, [])
+
+  const signInWithGoogle = useCallback(async () => {
+    return await authAdapter.signInWithGoogle()
+  }, [])
+
+  const signOut = useCallback(async () => {
+    await authAdapter.signOut()
+  }, [])
+
+  const sendPasswordReset = useCallback(async (email: string) => {
+    await authAdapter.sendPasswordReset(email)
+  }, [])
+
+  const resendEmailVerification = useCallback(async () => {
+    await authAdapter.resendEmailVerification()
+  }, [])
+
+  const updateProfile = useCallback(async (updates: { displayName?: string; photoURL?: string }) => {
+    await authAdapter.updateProfile(updates)
+
+    // Refresh user data from Firestore if available
+    if (instances?.auth.currentUser) {
+      await firestoreAdapter.getUser(instances.auth.currentUser.uid)
+    }
+  }, [instances])
+
+  const refreshUser = useCallback(async () => {
+    if (instances?.auth.currentUser) {
+      await firestoreAdapter.getUser(instances.auth.currentUser.uid)
+    }
+  }, [instances])
+
+  return {
+    firebaseUser: instances?.auth.currentUser || null,
+    user,
+    loading,
+    error,
+    isAuthenticated: !!instances?.auth.currentUser,
+    isEmailVerified: instances?.auth.currentUser?.emailVerified || false,
+    signIn,
+    signUp,
+    signInWithGoogle,
+    signOut,
+    sendPasswordReset,
+    resendEmailVerification,
+    updateProfile,
+    refreshUser,
+  }
+}
+

package/src/presentation/hooks/useFirestore.ts

@@ -0,0 +1,125 @@
+/**
+ * Firestore Hook
+ * @description React hook for Firestore real-time data
+ * Migrated from: /Users/umituz/Desktop/github/umituz/apps/web/app-growth-factory/src/domains/firebase/hooks/useFirestore.ts
+ */
+
+import { useEffect, useState } from 'react'
+import { doc, onSnapshot, query, collection, type QuerySnapshot, type DocumentData } from 'firebase/firestore'
+import type { Firestore } from 'firebase/firestore'
+
+export function useUser(db: Firestore, userId: string) {
+  const [user, setUser] = useState<any>(null)
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<Error | null>(null)
+
+  useEffect(() => {
+    if (!userId) {
+      setUser(null)
+      setLoading(false)
+      return
+    }
+
+    const unsubscribe = onSnapshot(doc(db, 'users', userId), (docSnap) => {
+      if (docSnap.exists()) {
+        setUser(docSnap.data())
+      } else {
+        setUser(null)
+      }
+      setLoading(false)
+    }, (err) => {
+      setError(err as Error)
+      setLoading(false)
+    })
+
+    return () => unsubscribe()
+  }, [db, userId])
+
+  return { user, loading, error }
+}
+
+export function useUserRealtime<T>(db: Firestore, collectionName: string, docId: string) {
+  const [data, setData] = useState<T | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<Error | null>(null)
+
+  useEffect(() => {
+    if (!docId) {
+      setData(null)
+      setLoading(false)
+      return
+    }
+
+    const unsubscribe = onSnapshot(doc(db, collectionName, docId), (docSnap) => {
+      if (docSnap.exists()) {
+        setData(docSnap.data() as T)
+      } else {
+        setData(null)
+      }
+      setLoading(false)
+    }, (err) => {
+      setError(err as Error)
+      setLoading(false)
+    })
+
+    return () => unsubscribe()
+  }, [db, collectionName, docId])
+
+  return { data, loading, error }
+}
+
+export function useCollectionRealtime<T>(
+  db: Firestore,
+  collectionName: string,
+  constraints?: any[]
+) {
+  const [data, setData] = useState<T[]>([])
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<Error | null>(null)
+
+  useEffect(() => {
+    const q = constraints
+      ? query(collection(db, collectionName), ...constraints)
+      : collection(db, collectionName)
+
+    const unsubscribe = onSnapshot(q, (querySnap: QuerySnapshot<DocumentData>) => {
+      const items = querySnap.docs.map((doc) => ({ id: doc.id, ...doc.data() } as T))
+      setData(items)
+      setLoading(false)
+    }, (err) => {
+      setError(err as Error)
+      setLoading(false)
+    })
+
+    return () => unsubscribe()
+  }, [db, collectionName, JSON.stringify(constraints)])
+
+  return { data, loading, error }
+}
+
+export function useDocumentValue<T>(
+  db: Firestore,
+  collectionName: string,
+  docId: string
+) {
+  const [data, setData] = useState<T | null>(null)
+
+  useEffect(() => {
+    if (!docId) {
+      setData(null)
+      return
+    }
+
+    const unsubscribe = onSnapshot(doc(db, collectionName, docId), (docSnap) => {
+      if (docSnap.exists()) {
+        setData(docSnap.data() as T)
+      } else {
+        setData(null)
+      }
+    })
+
+    return () => unsubscribe()
+  }, [db, collectionName, docId])
+
+  return data
+}

package/src/presentation/hooks/useStorage.ts

@@ -0,0 +1,141 @@
+/**
+ * Storage Hook
+ * @description React hook for file storage operations
+ * Migrated from: /Users/umituz/Desktop/github/umituz/apps/web/app-growth-factory/src/domains/firebase/hooks/useStorage.ts
+ */
+
+import { useState, useCallback } from 'react'
+import type { IFileRepository } from '../../domain/interfaces/file.repository.interface'
+import type { UploadProgress, UploadResult } from '../../domain/entities/file.entity'
+
+export interface UseStorageOptions {
+  fileRepository: IFileRepository
+  userId: string
+}
+
+export function useStorage({ fileRepository, userId }: UseStorageOptions) {
+  const [uploading, setUploading] = useState(false)
+  const [progress, setProgress] = useState(0)
+  const [error, setError] = useState<Error | null>(null)
+
+  const uploadFile = useCallback(
+    async (path: string, file: File): Promise<UploadResult> => {
+      setUploading(true)
+      setProgress(0)
+      setError(null)
+
+      try {
+        const result = await fileRepository.uploadFile(userId, path, file, {
+          onProgress: (progress: UploadProgress) => {
+            setProgress(progress.progress)
+          },
+        })
+
+        setProgress(100)
+        return result
+      } catch (err) {
+        setError(err as Error)
+        throw err
+      } finally {
+        setUploading(false)
+      }
+    },
+    [fileRepository, userId]
+  )
+
+  const uploadImage = useCallback(
+    async (file: File): Promise<UploadResult> => {
+      return uploadFile('images', file)
+    },
+    [uploadFile]
+  )
+
+  const uploadVideo = useCallback(
+    async (file: File): Promise<UploadResult> => {
+      return uploadFile('videos', file)
+    },
+    [uploadFile]
+  )
+
+  const uploadDocument = useCallback(
+    async (file: File): Promise<UploadResult> => {
+      return uploadFile('documents', file)
+    },
+    [uploadFile]
+  )
+
+  const uploadProfilePicture = useCallback(
+    async (file: File): Promise<UploadResult> => {
+      setUploading(true)
+      setError(null)
+
+      try {
+        const result = await fileRepository.uploadProfilePicture(userId, file)
+        return result
+      } catch (err) {
+        setError(err as Error)
+        throw err
+      } finally {
+        setUploading(false)
+      }
+    },
+    [fileRepository, userId]
+  )
+
+  const deleteFile = useCallback(
+    async (path: string): Promise<void> => {
+      setUploading(true)
+      setError(null)
+
+      try {
+        await fileRepository.deleteFile(path)
+      } catch (err) {
+        setError(err as Error)
+        throw err
+      } finally {
+        setUploading(false)
+      }
+    },
+    [fileRepository]
+  )
+
+  const listUserImages = useCallback(
+    async (): Promise<string[]> => {
+      setError(null)
+      try {
+        return await fileRepository.listUserImages(userId)
+      } catch (err) {
+        setError(err as Error)
+        throw err
+      }
+    },
+    [fileRepository, userId]
+  )
+
+  const listUserVideos = useCallback(
+    async (): Promise<string[]> => {
+      setError(null)
+      try {
+        return await fileRepository.listUserVideos(userId)
+      } catch (err) {
+        setError(err as Error)
+        throw err
+      }
+    },
+    [fileRepository, userId]
+  )
+
+  return {
+    uploadFile,
+    uploadImage,
+    uploadVideo,
+    uploadDocument,
+    uploadProfilePicture,
+    deleteFile,
+    listUserImages,
+    listUserVideos,
+    uploading,
+    progress,
+    error,
+  }
+}

package/src/presentation/providers/FirebaseProvider.tsx

@@ -0,0 +1,95 @@
+/**
+ * FirebaseProvider
+ * @description React Context Provider for Firebase with auth state tracking
+ */
+
+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'
+
+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, 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: 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(): FirebaseContextValue {
+  const context = useContext(FirebaseContext)
+  if (!context) {
+    throw new Error('useFirebaseContext must be used within FirebaseProvider')
+  }
+  return context
+}
+