@umituz/web-firebase 1.0.5 → 2.0.1

package/src/presentation/hooks/useAuth.ts

@@ -0,0 +1,153 @@
+/**
+ * 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
+ */
+
+import { useEffect, useState, useCallback } from 'react'
+import { 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
+}
+
+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)
+    })
+
+    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])
+
+  const signInWithGoogle = useCallback(async () => {
+    setError(null)
+    try {
+      return await authRepository.signInWithGoogle()
+    } catch (err) {
+      setError(err as Error)
+      throw err
+    }
+  }, [authRepository])
+
+  const signOut = useCallback(async () => {
+    setError(null)
+    try {
+      await authRepository.signOut()
+      setUser(null)
+      setFirebaseUser(null)
+    } catch (err) {
+      setError(err as Error)
+      throw err
+    }
+  }, [authRepository])
+
+  const sendPasswordReset = useCallback(async (email: string) => {
+    setError(null)
+    try {
+      await authRepository.sendPasswordReset(email)
+    } catch (err) {
+      setError(err as Error)
+      throw err
+    }
+  }, [authRepository])
+
+  const resendEmailVerification = useCallback(async () => {
+    setError(null)
+    try {
+      await authRepository.resendEmailVerification()
+    } catch (err) {
+      setError(err as Error)
+      throw err
+    }
+  }, [authRepository])
+
+  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
+    }
+  }, [authRepository, userRepository, firebaseUser])
+
+  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
+    }
+  }, [userRepository, firebaseUser])
+
+  return {
+    firebaseUser,
+    user,
+    loading,
+    error,
+    isAuthenticated: !!firebaseUser,
+    isEmailVerified: firebaseUser?.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,40 @@
+/**
+ * FirebaseProvider
+ * @description React Context Provider for Firebase initialization
+ */
+
+import { createContext, useContext, type ReactNode } from 'react'
+import type { FirebaseInstances } from '../../infrastructure/firebase/client'
+import { getFirebaseInstances } from '../../infrastructure/firebase/client'
+
+interface FirebaseContextValue {
+  instances: FirebaseInstances
+  isInitialized: boolean
+}
+
+const FirebaseContext = createContext<FirebaseContextValue | null>(null)
+
+export interface FirebaseProviderProps {
+  children: ReactNode
+}
+
+export function FirebaseProvider({ children }: FirebaseProviderProps) {
+  // Note: Firebase is already initialized via environment variables
+  // This provider just makes instances available via context
+  const instances = getFirebaseInstances()
+
+  const value: FirebaseContextValue = {
+    instances,
+    isInitialized: true,
+  }
+
+  return <FirebaseContext.Provider value={value}>{children}</FirebaseContext.Provider>
+}
+
+export function useFirebaseContext() {
+  const context = useContext(FirebaseContext)
+  if (!context) {
+    throw new Error('useFirebaseContext must be used within FirebaseProvider')
+  }
+  return context
+}