@umituz/web-firebase 3.2.3 → 3.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/web-firebase",
-  "version": "3.2.3",
+  "version": "3.3.0",
   "description": "Comprehensive Firebase integration with domain-based architecture for web applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -21,7 +21,10 @@
     "src"
   ],
   "scripts": {
-    "typecheck": "tsc --noEmit"
+    "build": "npm run clean && tsc",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "firebase",

package/src/application/use-cases/auth/sign-in-with-google.use-case.ts

@@ -6,7 +6,6 @@
 import type { UserCredential } from 'firebase/auth'
 import type { IAuthRepository } from '../../../domain/interfaces/auth.repository.interface'
 import type { IUserRepository } from '../../../domain/interfaces/user.repository.interface'
-import type { CreateUserDTO } from '../../dto/user.dto'
 import { createAuthError, AuthErrorCode } from '../../../domain/errors/auth.errors'
 
 export class SignInWithGoogleUseCase {
@@ -27,16 +26,19 @@ export class SignInWithGoogleUseCase {
       const existingUser = await this.userRepository.getUser(result.user.uid)
       if (!existingUser) {
         // New user - create user document
-        const createUserDTO: CreateUserDTO = {
-          id: result.user.uid,
-          email: result.user.email || '',
-          displayName: result.user.displayName || '',
-          photoURL: result.user.photoURL || undefined,
-          phoneNumber: result.user.phoneNumber || undefined,
-          emailVerified: result.user.emailVerified,
-        }
-
-        await this.authRepository.createUserDocument(result.user.uid, createUserDTO)
+        await this.userRepository.createUser(result.user.uid, {
+          profile: {
+            id: result.user.uid,
+            email: result.user.email || '',
+            displayName: result.user.displayName || '',
+            photoURL: result.user.photoURL || undefined,
+            phoneNumber: result.user.phoneNumber || undefined,
+            emailVerified: result.user.emailVerified,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            lastLoginAt: Date.now(),
+          }
+        } as any)
       }
 
       return result

package/src/domain/interfaces/file.repository.interface.ts

@@ -3,21 +3,33 @@
  * @description Generic contract for file storage operations
  */
 
+import type { UploadResult, UploadOptions } from '../entities/file.entity'
+
 export interface IFileRepository {
   /**
    * Upload file to storage
    */
-  uploadFile(userId: string, path: string, file: File | Blob, options?: any): Promise<any>
+  uploadFile(userId: string, path: string, file: File | Blob, options?: UploadOptions): Promise<UploadResult>
 
   /**
    * Upload image with automatic categorization
    */
-  uploadImage(userId: string, file: File, filename?: string): Promise<any>
+  uploadImage(userId: string, file: File, filename?: string): Promise<UploadResult>
+
+  /**
+   * Upload video with automatic categorization
+   */
+  uploadVideo(userId: string, file: File, filename?: string): Promise<UploadResult>
+
+  /**
+   * Upload document with automatic categorization
+   */
+  uploadDocument(userId: string, file: File, filename?: string): Promise<UploadResult>
 
   /**
    * Upload profile picture
    */
-  uploadProfilePicture(userId: string, file: File): Promise<any>
+  uploadProfilePicture(userId: string, file: File): Promise<UploadResult>
 
   /**
    * Get download URL for a file
@@ -34,11 +46,24 @@ export interface IFileRepository {
    */
   deleteUserFiles(userId: string): Promise<void>
 
+  /**
+   * Delete specific media types
+   */
+  deleteImage(userId: string, filename: string): Promise<void>
+  deleteVideo(userId: string, filename: string): Promise<void>
+  deleteProfilePicture(userId: string, filename: string): Promise<void>
+
   /**
    * List user files
    */
   listUserFiles(userId: string, path?: string): Promise<string[]>
 
+  /**
+   * List specific media types
+   */
+  listUserImages(userId: string): Promise<string[]>
+  listUserVideos(userId: string): Promise<string[]>
+
   /**
    * Validate file before upload
    */

package/src/domain/interfaces/user.repository.interface.ts

@@ -3,46 +3,18 @@
  * @description Generic contract for user data operations
  */
 
-import type { QueryConstraint } from 'firebase/firestore'
+import type { User } from '../entities/user.entity'
 
 export interface IUserRepository {
-  /**
-   * Get document by ID
-   */
-  getById<T>(userId: string): Promise<T | null>
-
-  /**
-   * Get document by field
-   */
-  getByField<T>(collectionPath: string, field: string, value: any): Promise<T | null>
-
-  /**
-   * Create document
-   */
-  create(userId: string, data: any): Promise<void>
-
-  /**
-   * Update document
-   */
-  update(userId: string, data: any, options?: { merge?: boolean }): Promise<void>
-
-  /**
-   * Delete document
-   */
-  delete(userId: string): Promise<void>
-
-  /**
-   * Query collection with constraints
-   */
-  query<T>(collectionPath: string, constraints: QueryConstraint[]): Promise<T[]>
-
-  /**
-   * Subscribe to document changes
-   */
-  subscribeToDoc<T>(docPath: string, callback: (data: T | null) => void): () => void
-
-  /**
-   * Subscribe to collection changes
-   */
-  subscribeToCollection<T>(collectionPath: string, callback: (data: T[]) => void, constraints?: QueryConstraint[]): () => void
+  getUser(userId: string): Promise<User | null>
+  getUserByEmail(email: string): Promise<User | null>
+  createUser(userId: string, data: Partial<User>): Promise<void>
+  updateUser(userId: string, data: Partial<User>): Promise<void>
+  deleteUser(userId: string): Promise<void>
+  updateProfile(userId: string, updates: Partial<Pick<User['profile'], 'displayName' | 'photoURL' | 'phoneNumber'>>): Promise<void>
+  updateSettings(userId: string, settings: Partial<User['settings']>): Promise<void>
+  updateSubscription(userId: string, subscription: Partial<User['subscription']>): Promise<void>
+  updateLastLogin(userId: string): Promise<void>
+  queryUsers(constraints: any[]): Promise<User[]>
+  subscribeToUser(userId: string, callback: (user: User | null) => void, onError?: (error: Error) => void): () => void
 }

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()
@@ -320,8 +324,8 @@ export class AuthAdapter implements IAuthRepository {
     return this.auth.currentUser
   }
 
-  onAuthStateChanged(callback: (user: FirebaseUser | null) => void) {
-    return this.auth.onAuthStateChanged(callback)
+  onAuthStateChanged(callback: (user: FirebaseUser | null) => void, onError?: (error: Error) => void) {
+    return this.auth.onAuthStateChanged(callback, onError)
   }
 
   // ==================== Token Management ====================

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.env.VITE_FIREBASE_API_KEY,
-  authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
-  projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
-  storageBucket: import.meta.env.VITE_FIREBASE_STORAGE_BUCKET,
-  messagingSenderId: import.meta.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
-  appId: import.meta.env.VITE_FIREBASE_APP_ID,
-  measurementId: import.meta.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