@umituz/web-firebase 1.0.4 → 2.0.1

package/src/infrastructure/services/firestore.repository.ts

@@ -0,0 +1,66 @@
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  setDoc,
+  updateDoc,
+  deleteDoc,
+  query,
+  type QueryConstraint,
+  type DocumentData,
+  type Firestore,
+  type CollectionReference,
+} from 'firebase/firestore';
+import type { IBaseRepository } from '../../domain/interfaces/repository.interface';
+
+/**
+ * Firestore Repository Implementation
+ * @description Generic CRUD operations for Firestore collections
+ */
+export class FirestoreRepository<T extends DocumentData> implements IBaseRepository<T> {
+  constructor(
+    protected db: Firestore,
+    protected collectionName: string,
+  ) {}
+
+  protected getCollection(parentPath?: string): CollectionReference<T> {
+    const fullPath = parentPath ? `${parentPath}/${this.collectionName}` : this.collectionName;
+    return collection(this.db, fullPath) as CollectionReference<T>;
+  }
+
+  protected getDocRef(id: string, parentPath?: string) {
+    const fullPath = parentPath ? `${parentPath}/${this.collectionName}` : this.collectionName;
+    return doc(this.db, fullPath, id);
+  }
+
+  async getById(id: string, parentPath?: string): Promise<T | null> {
+    const snap = await getDoc(this.getDocRef(id, parentPath));
+    return snap.exists() ? ({ id: snap.id, ...snap.data() } as unknown as T) : null;
+  }
+
+  async getAll(constraints: QueryConstraint[] = [], parentPath?: string): Promise<T[]> {
+    const q = query(this.getCollection(parentPath), ...constraints);
+    const snap = await getDocs(q);
+    return snap.docs.map((d) => ({ id: d.id, ...d.data() } as unknown as T));
+  }
+
+  async create(id: string, data: Omit<T, 'id'>, parentPath?: string): Promise<void> {
+    await setDoc(this.getDocRef(id, parentPath), {
+      ...data,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+  }
+
+  async update(id: string, data: Partial<T>, parentPath?: string): Promise<void> {
+    await updateDoc(this.getDocRef(id, parentPath), {
+      ...(data as DocumentData),
+      updatedAt: new Date().toISOString(),
+    });
+  }
+
+  async delete(id: string, parentPath?: string): Promise<void> {
+    await deleteDoc(this.getDocRef(id, parentPath));
+  }
+}

package/src/infrastructure/utils/storage.util.ts

@@ -0,0 +1,46 @@
+import {
+  ref,
+  uploadBytes,
+  uploadString,
+  getDownloadURL,
+  deleteObject,
+  type FirebaseStorage,
+} from 'firebase/storage';
+
+/**
+ * Firebase Storage Utils
+ * @description Upload and delete helpers for Firebase Storage
+ */
+
+export interface StorageUploadResult {
+  url: string;
+  path: string;
+}
+
+export async function uploadFile(
+  storage: FirebaseStorage,
+  path: string,
+  file: File | Blob,
+): Promise<StorageUploadResult> {
+  const storageRef = ref(storage, path);
+  await uploadBytes(storageRef, file);
+  const url = await getDownloadURL(storageRef);
+  return { url, path };
+}
+
+export async function uploadBase64(
+  storage: FirebaseStorage,
+  path: string,
+  base64: string,
+  mimeType = 'image/jpeg',
+): Promise<StorageUploadResult> {
+  const storageRef = ref(storage, path);
+  const dataUrl = base64.startsWith('data:') ? base64 : `data:${mimeType};base64,${base64}`;
+  await uploadString(storageRef, dataUrl, 'data_url');
+  const url = await getDownloadURL(storageRef);
+  return { url, path };
+}
+
+export async function deleteFile(storage: FirebaseStorage, path: string): Promise<void> {
+  await deleteObject(ref(storage, path));
+}

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/useFirebaseAuth.ts

@@ -0,0 +1,122 @@
+import { useState, useEffect, useCallback } from 'react';
+import {
+  type Auth,
+  type UserCredential,
+  type User,
+  onAuthStateChanged,
+  signInWithEmailAndPassword,
+  createUserWithEmailAndPassword,
+  signOut as firebaseSignOut,
+  updateProfile,
+  updatePassword,
+  sendPasswordResetEmail,
+} from 'firebase/auth';
+import type { FirebaseUser } from '../../domain/entities/firebase.entity';
+
+function mapUser(u: User): FirebaseUser {
+  return {
+    uid: u.uid,
+    email: u.email,
+    displayName: u.displayName,
+    photoURL: u.photoURL,
+    emailVerified: u.emailVerified,
+  };
+}
+
+/**
+ * useFirebaseAuth Hook
+ * @description Hook to manage Firebase authentication state and operations
+ */
+
+export interface UseFirebaseAuthOptions {
+  onUserChange?: (user: FirebaseUser | null) => void;
+}
+
+export interface UseFirebaseAuthReturn {
+  user: FirebaseUser | null;
+  loading: boolean;
+  isAuthenticated: boolean;
+  signIn(email: string, password: string): Promise<UserCredential>;
+  signUp(email: string, password: string, name?: string): Promise<UserCredential>;
+  signOut(): Promise<void>;
+  updateUserProfile(name: string, photoURL?: string): Promise<void>;
+  updateUserPassword(newPassword: string): Promise<void>;
+  resetPassword(email: string): Promise<void>;
+  getIdToken(): Promise<string>;
+}
+
+export function useFirebaseAuth(
+  auth: Auth,
+  options?: UseFirebaseAuthOptions,
+): UseFirebaseAuthReturn {
+  const [user, setUser] = useState<FirebaseUser | null>(null);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    const unsub = onAuthStateChanged(auth, (firebaseUser) => {
+      const mapped = firebaseUser ? mapUser(firebaseUser) : null;
+      setUser(mapped);
+      setLoading(false);
+      options?.onUserChange?.(mapped);
+    });
+    return unsub;
+  }, [auth, options]);
+
+  const signIn = useCallback(
+    (email: string, password: string) => signInWithEmailAndPassword(auth, email, password),
+    [auth],
+  );
+
+  const signUp = useCallback(
+    async (email: string, password: string, name?: string) => {
+      const cred = await createUserWithEmailAndPassword(auth, email, password);
+      if (name && cred.user) await updateProfile(cred.user, { displayName: name });
+      return cred;
+    },
+    [auth],
+  );
+
+  const signOut = useCallback(() => firebaseSignOut(auth), [auth]);
+
+  const updateUserProfile = useCallback(
+    async (name: string, photoURL?: string) => {
+      if (!auth.currentUser) throw new Error('No authenticated user');
+      await updateProfile(auth.currentUser, {
+        displayName: name,
+        ...(photoURL !== undefined && { photoURL }),
+      });
+    },
+    [auth],
+  );
+
+  const updateUserPassword = useCallback(
+    async (newPassword: string) => {
+      if (!auth.currentUser) throw new Error('No authenticated user');
+      await updatePassword(auth.currentUser, newPassword);
+    },
+    [auth],
+  );
+
+  const resetPassword = useCallback(
+    (email: string) => sendPasswordResetEmail(auth, email),
+    [auth],
+  );
+
+  const getIdToken = useCallback(async () => {
+    if (!auth.currentUser) throw new Error('No authenticated user');
+    return auth.currentUser.getIdToken();
+  }, [auth]);
+
+  return {
+    user,
+    loading,
+    isAuthenticated: !!user,
+    signIn,
+    signUp,
+    signOut,
+    updateUserProfile,
+    updateUserPassword,
+    resetPassword,
+    getIdToken,
+  };
+}

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/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Presentation Layer
+ * Subpath: @umituz/web-firebase/presentation
+ */
+
+export * from './hooks/useFirebaseAuth';

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
+}