@umituz/web-firebase 3.2.5 → 3.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/web-firebase",
-  "version": "3.2.5",
+  "version": "3.3.0",
   "description": "Comprehensive Firebase integration with domain-based architecture for web applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domains/firestore/services/firestore.service.ts

@@ -21,7 +21,11 @@ import type { User } from '../entities'
 
 class FirestoreService implements IFirestoreService {
   private get db() {
-    return getFirebaseDB()
+    const db = getFirebaseDB()
+    if (!db) {
+      throw new Error('Firestore not initialized. Call initializeFirebase() first.')
+    }
+    return db
   }
 
   private readonly USERS_COLLECTION = 'users'

package/src/domains/storage/services/storage.service.ts

@@ -21,7 +21,11 @@ import type {
 
 class StorageService implements IStorageService {
   private get storage() {
-    return getFirebaseStorage()
+    const storage = getFirebaseStorage()
+    if (!storage) {
+      throw new Error('Firebase Storage not initialized. Call initializeFirebase() first.')
+    }
+    return storage
   }
 
   // Upload Methods

package/src/index.ts

@@ -1,19 +1,10 @@
 /**
  * @umituz/web-firebase
- * Firebase integration for web applications with domain-based architecture
+ * Firebase client initialization and core services
  *
  * Usage:
- * import { AuthService } from '@umituz/web-firebase/auth'
- * import { FirestoreService } from '@umituz/web-firebase/firestore'
- * import { StorageService } from '@umituz/web-firebase/storage'
+ * import { initializeFirebase, getFirebaseDB } from '@umituz/web-firebase'
  */
 
 // Firebase client initialization
 export * from './infrastructure/firebase/client'
-
-// Presentation Layer (React components & hooks)
-export * from './presentation/index'
-
-// Re-export common types for convenience
-export type { FirebaseInstances } from './infrastructure/firebase/client'
-export type { FirebaseContextValue, FirebaseProviderProps } from './presentation/providers/FirebaseProvider'

package/src/infrastructure/firebase/auth.adapter.ts

@@ -36,7 +36,11 @@ import { getAuthConfig } from '../../domain/config/auth.config'
  */
 export class AuthAdapter implements IAuthRepository {
   private get auth() {
-    return getFirebaseAuth()
+    const auth = getFirebaseAuth()
+    if (!auth) {
+      throw new Error('Firebase Auth not initialized. Call initializeFirebase() first.')
+    }
+    return auth
   }
 
   private config = getAuthConfig()

package/src/infrastructure/firebase/client.ts

@@ -1,7 +1,7 @@
 /**
  * Firebase Client
  * @description Firebase initialization and singleton instances
- * Migrated from: /Users/umituz/Desktop/github/umituz/apps/web/app-growth-factory/src/domains/firebase/services/client.ts
+ * Migrated from: /Users/umuz/Desktop/github/umituz/apps/web/app-growth-factory/src/domains/firebase/services/client.ts
  */
 
 import { initializeApp, getApps, FirebaseApp } from 'firebase/app'
@@ -11,50 +11,75 @@ import { getStorage, FirebaseStorage } from 'firebase/storage'
 import { getAnalytics, Analytics } from 'firebase/analytics'
 import { getFunctions, Functions } from 'firebase/functions'
 
-const firebaseConfig = {
-  apiKey: (import.meta as any).env.VITE_FIREBASE_API_KEY,
-  authDomain: (import.meta as any).env.VITE_FIREBASE_AUTH_DOMAIN,
-  projectId: (import.meta as any).env.VITE_FIREBASE_PROJECT_ID,
-  storageBucket: (import.meta as any).env.VITE_FIREBASE_STORAGE_BUCKET,
-  messagingSenderId: (import.meta as any).env.VITE_FIREBASE_MESSAGING_SENDER_ID,
-  appId: (import.meta as any).env.VITE_FIREBASE_APP_ID,
-  measurementId: (import.meta as any).env.VITE_FIREBASE_MEASUREMENT_ID,
+/**
+ * Firebase Configuration interface
+ * Pass this to initializeFirebase()
+ */
+export interface FirebaseConfig {
+  apiKey: string
+  authDomain: string
+  projectId: string
+  storageBucket: string
+  messagingSenderId: string
+  appId: string
+  measurementId?: string
 }
 
 // Singleton instances
-let app: FirebaseApp
-let auth: Auth
-let db: Firestore
-let storage: FirebaseStorage
-let functions: Functions
+let app: FirebaseApp | null = null
+let auth: Auth | null = null
+let db: Firestore | null = null
+let storage: FirebaseStorage | null = null
+let functions: Functions | null = null
 let analytics: Analytics | null = null
 
 /**
- * Initialize Firebase App
+ * Initialize Firebase with provided configuration
+ * Must be called before using any Firebase services
+ *
+ * @param config - Firebase configuration object
+ * @returns FirebaseApp instance
  */
-export function initializeFirebase(): FirebaseApp {
-  if (!getApps().length) {
-    app = initializeApp(firebaseConfig)
-  } else {
+export function initializeFirebase(config: FirebaseConfig): FirebaseApp {
+  if (app) {
+    console.warn('Firebase already initialized')
+    return app
+  }
+
+  if (getApps().length > 0) {
     app = getApps()[0]
+    return app
   }
+
+  // Validate config
+  if (!config.apiKey || !config.projectId) {
+    throw new Error('Invalid Firebase config: apiKey and projectId are required')
+  }
+
+  app = initializeApp(config)
   return app
 }
 
 /**
  * Get Firebase App instance
+ * @returns FirebaseApp instance or null if not initialized
  */
-export function getFirebaseApp(): FirebaseApp {
-  return app || initializeFirebase()
+export function getFirebaseApp(): FirebaseApp | null {
+  return app
 }
 
 /**
  * Get Firebase Auth instance
+ * @returns Auth instance or null if not initialized
  */
-export function getFirebaseAuth(): Auth {
+export function getFirebaseAuth(): Auth | null {
+  if (!app) {
+    console.warn('Firebase not initialized. Call initializeFirebase(config) first.')
+    return null
+  }
   if (!auth) {
     const firebaseApp = getFirebaseApp()
-    if (typeof window !== 'undefined') {
+    if (firebaseApp && typeof window !== 'undefined') {
       try {
         auth = getAuth(firebaseApp)
       } catch (e) {
@@ -63,7 +88,7 @@ export function getFirebaseAuth(): Auth {
           persistence: browserLocalPersistence,
         })
       }
-    } else {
+    } else if (firebaseApp) {
       auth = getAuth(firebaseApp)
     }
   }
@@ -72,70 +97,99 @@ export function getFirebaseAuth(): Auth {
 
 /**
  * Get Firestore instance
+ * @returns Firestore instance or null if not initialized
  */
-export function getFirebaseDB(): Firestore {
+export function getFirebaseDB(): Firestore | null {
+  if (!app) {
+    console.warn('Firebase not initialized. Call initializeFirebase(config) first.')
+    return null
+  }
   if (!db) {
-    db = getFirestore(getFirebaseApp())
+    db = getFirestore(getFirebaseApp()!)
   }
   return db
 }
 
 /**
  * Get Firebase Storage instance
+ * @returns FirebaseStorage instance or null if not initialized
  */
-export function getFirebaseStorage(): FirebaseStorage {
+export function getFirebaseStorage(): FirebaseStorage | null {
+  if (!app) {
+    console.warn('Firebase not initialized. Call initializeFirebase(config) first.')
+    return null
+  }
   if (!storage) {
-    storage = getStorage(getFirebaseApp())
+    storage = getStorage(getFirebaseApp()!)
   }
   return storage
 }
 
 /**
  * Get Firebase Functions instance
+ * @returns Functions instance or null if not initialized
  */
-export function getFirebaseFunctions(): Functions {
+export function getFirebaseFunctions(): Functions | null {
+  if (!app) {
+    console.warn('Firebase not initialized. Call initializeFirebase(config) first.')
+    return null
+  }
   if (!functions) {
-    functions = getFunctions(getFirebaseApp())
+    functions = getFunctions(getFirebaseApp()!)
   }
   return functions
 }
 
 /**
  * Get Firebase Analytics instance
+ * @returns Analytics instance or null (not available in SSR or not initialized)
  */
 export function getFirebaseAnalytics(): Analytics | null {
+  if (!app) {
+    console.warn('Firebase not initialized. Call initializeFirebase(config) first.')
+    return null
+  }
   if (!analytics && typeof window !== 'undefined') {
-    analytics = getAnalytics(getFirebaseApp())
+    analytics = getAnalytics(getFirebaseApp()!)
   }
   return analytics
 }
 
 /**
  * Firebase Instances
- * All Firebase service instances
+ * All Firebase service instances (may be null if not initialized)
  */
 export interface FirebaseInstances {
   app: FirebaseApp
-  auth: Auth
-  db: Firestore
-  storage: FirebaseStorage
-  functions: Functions
+  auth: Auth | null
+  db: Firestore | null
+  storage: FirebaseStorage | null
+  functions: Functions | null
   analytics: Analytics | null
 }
 
 /**
  * Get all Firebase instances
+ * @returns FirebaseInstances or null if not initialized
  */
-export function getFirebaseInstances(): FirebaseInstances {
+export function getFirebaseInstances(): FirebaseInstances | null {
+  const app = getFirebaseApp()
+  if (!app) {
+    return null
+  }
   return {
-    app: getFirebaseApp(),
-    auth: getFirebaseAuth(),
-    db: getFirebaseDB(),
-    storage: getFirebaseStorage(),
-    functions: getFirebaseFunctions(),
+    app,
+    auth: getFirebaseAuth()!,
+    db: getFirebaseDB()!,
+    storage: getFirebaseStorage()!,
+    functions: getFirebaseFunctions()!,
     analytics: getFirebaseAnalytics(),
   }
 }
 
-// Export singleton instances for convenience
-export { app, auth, db, storage, functions, analytics }
+/**
+ * Check if Firebase is initialized
+ */
+export function isFirebaseInitialized(): boolean {
+  return app !== null
+}

package/src/infrastructure/firebase/firestore.adapter.ts

@@ -23,7 +23,11 @@ import { createRepositoryError, RepositoryErrorCode } from '../../domain/errors/
 
 export class FirestoreAdapter implements IUserRepository {
   private get db() {
-    return getFirebaseDB()
+    const db = getFirebaseDB()
+    if (!db) {
+      throw new Error('Firestore not initialized. Call initializeFirebase() first.')
+    }
+    return db
   }
 
   private readonly USERS_COLLECTION = 'users'

package/src/infrastructure/firebase/storage.adapter.ts

@@ -26,7 +26,11 @@ import { createRepositoryError, RepositoryErrorCode } from '../../domain/errors/
 
 export class StorageAdapter implements IFileRepository {
   private get storage() {
-    return getFirebaseStorage()
+    const storage = getFirebaseStorage()
+    if (!storage) {
+      throw new Error('Firebase Storage not initialized. Call initializeFirebase() first.')
+    }
+    return storage
   }
 
   // Upload Methods

package/src/presentation/hooks/useAuth.ts

@@ -1,392 +0,0 @@
-/**
- * Auth Hook
- * @description React hook for authentication with Google & Apple OAuth
- */
-
-import { useCallback, useEffect, useState } from 'react'
-import type { User as FirebaseUser } from 'firebase/auth'
-import type { User as FirestoreUser } from '../../domains/firestore/entities'
-import { authService } from '../../domains/auth/services'
-import { firestoreService } from '../../domains/firestore/services'
-import { useFirebaseContext } from '../providers/FirebaseProvider'
-import { getAuthConfig } from '../../domain/config/auth.config'
-
-export interface UseAuthResult {
-  // State
-  firebaseUser: FirebaseUser | null
-  user: FirestoreUser | null
-  loading: boolean
-  error: Error | null
-  isAuthenticated: boolean
-  isEmailVerified: boolean
-
-  // Email/Password Auth
-  signIn: (email: string, password: string) => Promise<FirebaseUser>
-  signUp: (email: string, password: string, displayName: string) => Promise<FirebaseUser>
-
-  // OAuth Providers
-  signInWithGoogle: (useRedirect?: boolean) => Promise<FirebaseUser>
-  signInWithApple: (useRedirect?: boolean) => Promise<FirebaseUser>
-
-  // Provider Management
-  linkGoogle: () => Promise<void>
-  linkApple: () => Promise<void>
-  unlinkProvider: (providerId: string) => Promise<void>
-
-  // Account Management
-  signOut: () => Promise<void>
-  sendPasswordReset: (email: string) => Promise<void>
-  resendEmailVerification: () => Promise<void>
-  updateProfile: (updates: { displayName?: string; photoURL?: string }) => Promise<void>
-  updateEmail: (newEmail: string, password: string) => Promise<void>
-  updatePassword: (currentPassword: string, newPassword: string) => Promise<void>
-  deleteAccount: (password: string) => Promise<void>
-
-  // Token Management
-  getIdToken: (forceRefresh?: boolean) => Promise<string>
-  refreshToken: () => Promise<void>
-
-  // User Data
-  refreshUser: () => Promise<void>
-
-  // Config
-  googleEnabled: boolean
-  appleEnabled: boolean
-  emailPasswordEnabled: boolean
-}
-
-export function useAuth(): UseAuthResult {
-  const { instances, loading, error } = useFirebaseContext()
-  const [user, setUser] = useState<FirestoreUser | null>(null)
-  const config = getAuthConfig()
-
-  // Fetch user data from Firestore
-  useEffect(() => {
-    const fetchUser = async () => {
-      const currentUser = instances?.auth.currentUser
-      if (currentUser) {
-        try {
-          const userData = await firestoreService.getUser(currentUser.uid)
-          setUser(userData)
-        } catch (err) {
-          console.error('Error fetching user data:', err)
-          setUser(null)
-        }
-      } else {
-        setUser(null)
-      }
-    }
-    fetchUser()
-  }, [instances?.auth.currentUser])
-
-  // Email/Password Sign In
-  const signIn = useCallback(async (email: string, password: string) => {
-    const result = await authService.signIn(email, password)
-    return result.user
-  }, [])
-
-  // Email/Password Sign Up
-  const signUp = useCallback(async (email: string, password: string, displayName: string) => {
-    const userCredential = await authService.signUp(email, password, displayName)
-
-    // Create user profile in Firestore if auto-create is enabled
-    if (config.shouldCreateUserDocument()) {
-      const now = Date.now()
-      const defaultSettings = config.getConfig().defaultUserSettings
-
-      await firestoreService.createUser(userCredential.user.uid, {
-        profile: {
-          id: userCredential.user.uid,
-          email: email,
-          displayName: displayName,
-          createdAt: now,
-          updatedAt: now,
-          lastLoginAt: now,
-          emailVerified: false,
-        },
-        settings: {
-          theme: defaultSettings?.theme ?? 'system',
-          language: defaultSettings?.language ?? 'en',
-          timezone: defaultSettings?.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
-          currency: defaultSettings?.currency ?? 'USD',
-          notifications: {
-            email: defaultSettings?.notifications?.email ?? true,
-            push: defaultSettings?.notifications?.push ?? true,
-            marketing: defaultSettings?.notifications?.marketing ?? false,
-            security: defaultSettings?.notifications?.security ?? true,
-            weeklyDigest: defaultSettings?.notifications?.weeklyDigest ?? false,
-          },
-          privacy: {
-            profileVisibility: defaultSettings?.privacy?.profileVisibility ?? 'public',
-            showEmail: defaultSettings?.privacy?.showEmail ?? false,
-            showPhone: defaultSettings?.privacy?.showPhone ?? false,
-            dataSharing: defaultSettings?.privacy?.dataSharing ?? false,
-          },
-        },
-        subscription: {
-          plan: config.getConfig().defaultSubscriptionPlan ?? 'free',
-          status: 'active',
-          cancelAtPeriodEnd: false,
-          createdAt: now,
-          updatedAt: now,
-        },
-      })
-    }
-
-    return userCredential.user
-  }, [config])
-
-  // Google Sign In
-  const signInWithGoogleCallback = useCallback(async (useRedirect = false): Promise<FirebaseUser> => {
-    const result = await authService.signInWithGoogle(useRedirect)
-
-    // Create user profile in Firestore if it doesn't exist
-    if (config.shouldCreateUserDocument()) {
-      const existingUser = await firestoreService.getUser(result.user.uid)
-      if (!existingUser) {
-        const now = Date.now()
-        const defaultSettings = config.getConfig().defaultUserSettings
-
-        await firestoreService.createUser(result.user.uid, {
-          profile: {
-            id: result.user.uid,
-            email: result.user.email ?? '',
-            displayName: result.user.displayName ?? '',
-            photoURL: result.user.photoURL || undefined,
-            createdAt: now,
-            updatedAt: now,
-            lastLoginAt: now,
-            emailVerified: result.user.emailVerified,
-          },
-          settings: {
-            theme: defaultSettings?.theme ?? 'system',
-            language: defaultSettings?.language ?? 'en',
-            timezone: defaultSettings?.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
-            currency: defaultSettings?.currency ?? 'USD',
-            notifications: {
-              email: defaultSettings?.notifications?.email ?? true,
-              push: defaultSettings?.notifications?.push ?? true,
-              marketing: defaultSettings?.notifications?.marketing ?? false,
-              security: defaultSettings?.notifications?.security ?? true,
-              weeklyDigest: defaultSettings?.notifications?.weeklyDigest ?? false,
-            },
-            privacy: {
-              profileVisibility: defaultSettings?.privacy?.profileVisibility ?? 'public',
-              showEmail: defaultSettings?.privacy?.showEmail ?? false,
-              showPhone: defaultSettings?.privacy?.showPhone ?? false,
-              dataSharing: defaultSettings?.privacy?.dataSharing ?? false,
-            },
-          },
-          subscription: {
-            plan: config.getConfig().defaultSubscriptionPlan ?? 'free',
-            status: 'active',
-            cancelAtPeriodEnd: false,
-            createdAt: now,
-            updatedAt: now,
-          },
-        })
-      }
-    }
-
-    return result.user
-  }, [config])
-
-  // Apple Sign In
-  const signInWithAppleCallback = useCallback(async (useRedirect = false): Promise<FirebaseUser> => {
-    const result = await authService.signInWithApple(useRedirect)
-
-    // Create user profile in Firestore if it doesn't exist
-    if (config.shouldCreateUserDocument()) {
-      const existingUser = await firestoreService.getUser(result.user.uid)
-      if (!existingUser) {
-        const now = Date.now()
-        const defaultSettings = config.getConfig().defaultUserSettings
-
-        await firestoreService.createUser(result.user.uid, {
-          profile: {
-            id: result.user.uid,
-            email: result.user.email ?? '',
-            displayName: result.user.displayName ?? '',
-            photoURL: result.user.photoURL || undefined,
-            createdAt: now,
-            updatedAt: now,
-            lastLoginAt: now,
-            emailVerified: result.user.emailVerified,
-          },
-          settings: {
-            theme: defaultSettings?.theme ?? 'system',
-            language: defaultSettings?.language ?? 'en',
-            timezone: defaultSettings?.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
-            currency: defaultSettings?.currency ?? 'USD',
-            notifications: {
-              email: defaultSettings?.notifications?.email ?? true,
-              push: defaultSettings?.notifications?.push ?? true,
-              marketing: defaultSettings?.notifications?.marketing ?? false,
-              security: defaultSettings?.notifications?.security ?? true,
-              weeklyDigest: defaultSettings?.notifications?.weeklyDigest ?? false,
-            },
-            privacy: {
-              profileVisibility: defaultSettings?.privacy?.profileVisibility ?? 'public',
-              showEmail: defaultSettings?.privacy?.showEmail ?? false,
-              showPhone: defaultSettings?.privacy?.showPhone ?? false,
-              dataSharing: defaultSettings?.privacy?.dataSharing ?? false,
-            },
-          },
-          subscription: {
-            plan: config.getConfig().defaultSubscriptionPlan ?? 'free',
-            status: 'active',
-            cancelAtPeriodEnd: false,
-            createdAt: now,
-            updatedAt: now,
-          },
-        })
-      }
-    }
-
-    return result.user
-  }, [config])
-
-  // Provider Linking
-  const linkGoogleCallback = useCallback(async () => {
-    await authService.linkGoogle()
-    // Refresh user data
-    const currentUser = instances?.auth.currentUser
-    if (currentUser) {
-      const userData = await firestoreService.getUser(currentUser.uid)
-      setUser(userData)
-    }
-  }, [instances])
-
-  const linkAppleCallback = useCallback(async () => {
-    await authService.linkApple()
-    // Refresh user data
-    const currentUser = instances?.auth.currentUser
-    if (currentUser) {
-      const userData = await firestoreService.getUser(currentUser.uid)
-      setUser(userData)
-    }
-  }, [instances])
-
-  const unlinkProviderCallback = useCallback(async (providerId: string) => {
-    await authService.unlinkProvider(providerId)
-    // Refresh user data
-    const currentUser = instances?.auth.currentUser
-    if (currentUser) {
-      const userData = await firestoreService.getUser(currentUser.uid)
-      setUser(userData)
-    }
-  }, [instances])
-
-  // Sign Out
-  const signOut = useCallback(async () => {
-    await authService.signOut()
-    setUser(null)
-  }, [])
-
-  // Password Reset
-  const sendPasswordReset = useCallback(async (email: string) => {
-    await authService.sendPasswordReset(email)
-  }, [])
-
-  // Email Verification
-  const resendEmailVerification = useCallback(async () => {
-    await authService.resendEmailVerification()
-  }, [])
-
-  // Update Profile
-  const updateProfile = useCallback(async (updates: { displayName?: string; photoURL?: string }) => {
-    await authService.updateProfile(updates)
-
-    // Refresh user data from Firestore
-    const currentUser = instances?.auth.currentUser
-    if (currentUser) {
-      const userData = await firestoreService.getUser(currentUser.uid)
-      setUser(userData)
-    }
-  }, [instances])
-
-  // Update Email
-  const updateEmailCallback = useCallback(async (newEmail: string, password: string) => {
-    await authService.updateEmail(newEmail, password)
-
-    // Refresh user data
-    const currentUser = instances?.auth.currentUser
-    if (currentUser) {
-      const userData = await firestoreService.getUser(currentUser.uid)
-      setUser(userData)
-    }
-  }, [instances])
-
-  // Update Password
-  const updatePasswordCallback = useCallback(async (currentPassword: string, newPassword: string) => {
-    await authService.updatePassword(currentPassword, newPassword)
-  }, [])
-
-  // Delete Account
-  const deleteAccountCallback = useCallback(async (password: string) => {
-    await authService.deleteAccount(password)
-    setUser(null)
-  }, [])
-
-  // Token Management
-  const getIdTokenCallback = useCallback(async (forceRefresh = false) => {
-    return await authService.getIdToken(forceRefresh)
-  }, [])
-
-  const refreshTokenCallback = useCallback(async () => {
-    await authService.refreshToken()
-  }, [])
-
-  // Refresh User Data
-  const refreshUser = useCallback(async () => {
-    const currentUser = instances?.auth.currentUser
-    if (currentUser) {
-      const userData = await firestoreService.getUser(currentUser.uid)
-      setUser(userData)
-    }
-  }, [instances])
-
-  return {
-    // State
-    firebaseUser: instances?.auth.currentUser || null,
-    user,
-    loading,
-    error,
-    isAuthenticated: !!instances?.auth.currentUser,
-    isEmailVerified: instances?.auth.currentUser?.emailVerified || false,
-
-    // Email/Password Auth
-    signIn,
-    signUp,
-
-    // OAuth Providers
-    signInWithGoogle: signInWithGoogleCallback,
-    signInWithApple: signInWithAppleCallback,
-
-    // Provider Management
-    linkGoogle: linkGoogleCallback,
-    linkApple: linkAppleCallback,
-    unlinkProvider: unlinkProviderCallback,
-
-    // Account Management
-    signOut,
-    sendPasswordReset,
-    resendEmailVerification,
-    updateProfile,
-    updateEmail: updateEmailCallback,
-    updatePassword: updatePasswordCallback,
-    deleteAccount: deleteAccountCallback,
-
-    // Token Management
-    getIdToken: getIdTokenCallback,
-    refreshToken: refreshTokenCallback,
-
-    // User Data
-    refreshUser,
-
-    // Config
-    googleEnabled: config.isGoogleEnabled(),
-    appleEnabled: config.isAppleEnabled(),
-    emailPasswordEnabled: config.isEmailPasswordEnabled(),
-  }
-}

package/src/presentation/hooks/useFirebaseAuth.ts

@@ -1,122 +0,0 @@
-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

@@ -1,125 +0,0 @@
-/**
- * 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

@@ -1,141 +0,0 @@
-/**
- * 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

@@ -1,10 +0,0 @@
-/**
- * Presentation Layer
- * Subpath: @umituz/web-firebase/presentation
- */
-
-export * from './hooks/useAuth';
-export * from './hooks/useFirebaseAuth';
-export * from './hooks/useFirestore';
-export * from './hooks/useStorage';
-export * from './providers/FirebaseProvider';

package/src/presentation/providers/FirebaseProvider.tsx

@@ -1,90 +0,0 @@
-/**
- * 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 type { AuthUser } from '../../domains/auth/entities'
-import { authService } from '../../domains/auth/services'
-
-export interface FirebaseContextValue {
-  instances: FirebaseInstances
-  isInitialized: boolean
-  user: User | null
-  authUser: AuthUser | 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 [authUser, setAuthUser] = useState<AuthUser | 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 unsubscribe = authService.onAuthStateChanged(
-        (newAuthUser) => {
-          setAuthUser(newAuthUser)
-          setUser(newAuthUser ? (firebaseInstances.auth.currentUser || null) : null)
-          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,
-    authUser,
-    loading,
-    error,
-  }
-
-  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
-}