@umituz/web-firebase 1.0.4 → 2.0.1

package/src/infrastructure/firebase/client.ts

@@ -0,0 +1,141 @@
+/**
+ * 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
+ */
+
+import { initializeApp, getApps, FirebaseApp } from 'firebase/app'
+import { initializeAuth, getAuth, Auth, browserLocalPersistence } from 'firebase/auth'
+import { getFirestore, Firestore } from 'firebase/firestore'
+import { getStorage, FirebaseStorage } from 'firebase/storage'
+import { getAnalytics, Analytics } from 'firebase/analytics'
+import { getFunctions, Functions } from 'firebase/functions'
+
+const firebaseConfig = {
+  apiKey: process.env.VITE_FIREBASE_API_KEY,
+  authDomain: process.env.VITE_FIREBASE_AUTH_DOMAIN,
+  projectId: process.env.VITE_FIREBASE_PROJECT_ID,
+  storageBucket: process.env.VITE_FIREBASE_STORAGE_BUCKET,
+  messagingSenderId: process.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
+  appId: process.env.VITE_FIREBASE_APP_ID,
+  measurementId: process.env.VITE_FIREBASE_MEASUREMENT_ID,
+}
+
+// Singleton instances
+let app: FirebaseApp
+let auth: Auth
+let db: Firestore
+let storage: FirebaseStorage
+let functions: Functions
+let analytics: Analytics | null = null
+
+/**
+ * Initialize Firebase App
+ */
+export function initializeFirebase(): FirebaseApp {
+  if (!getApps().length) {
+    app = initializeApp(firebaseConfig)
+  } else {
+    app = getApps()[0]
+  }
+  return app
+}
+
+/**
+ * Get Firebase App instance
+ */
+export function getFirebaseApp(): FirebaseApp {
+  return app || initializeFirebase()
+}
+
+/**
+ * Get Firebase Auth instance
+ */
+export function getFirebaseAuth(): Auth {
+  if (!auth) {
+    const firebaseApp = getFirebaseApp()
+    if (typeof window !== 'undefined') {
+      try {
+        auth = getAuth(firebaseApp)
+      } catch (e) {
+        console.warn('getAuth failed, trying initializeAuth...', e)
+        auth = initializeAuth(firebaseApp, {
+          persistence: browserLocalPersistence,
+        })
+      }
+    } else {
+      auth = getAuth(firebaseApp)
+    }
+  }
+  return auth
+}
+
+/**
+ * Get Firestore instance
+ */
+export function getFirebaseDB(): Firestore {
+  if (!db) {
+    db = getFirestore(getFirebaseApp())
+  }
+  return db
+}
+
+/**
+ * Get Firebase Storage instance
+ */
+export function getFirebaseStorage(): FirebaseStorage {
+  if (!storage) {
+    storage = getStorage(getFirebaseApp())
+  }
+  return storage
+}
+
+/**
+ * Get Firebase Functions instance
+ */
+export function getFirebaseFunctions(): Functions {
+  if (!functions) {
+    functions = getFunctions(getFirebaseApp())
+  }
+  return functions
+}
+
+/**
+ * Get Firebase Analytics instance
+ */
+export function getFirebaseAnalytics(): Analytics | null {
+  if (!analytics && typeof window !== 'undefined') {
+    analytics = getAnalytics(getFirebaseApp())
+  }
+  return analytics
+}
+
+/**
+ * Firebase Instances
+ * All Firebase service instances
+ */
+export interface FirebaseInstances {
+  app: FirebaseApp
+  auth: Auth
+  db: Firestore
+  storage: FirebaseStorage
+  functions: Functions
+  analytics: Analytics | null
+}
+
+/**
+ * Get all Firebase instances
+ */
+export function getFirebaseInstances(): FirebaseInstances {
+  return {
+    app: getFirebaseApp(),
+    auth: getFirebaseAuth(),
+    db: getFirebaseDB(),
+    storage: getFirebaseStorage(),
+    functions: getFirebaseFunctions(),
+    analytics: getFirebaseAnalytics(),
+  }
+}
+
+// Export singleton instances for convenience
+export { app, auth, db, storage, functions, analytics }

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

@@ -0,0 +1,190 @@
+/**
+ * Firestore Adapter
+ * @description Firebase Firestore implementation of IUserRepository
+ * Migrated from: /Users/umituz/Desktop/github/umituz/apps/web/app-growth-factory/src/domains/firebase/services/firestore.ts
+ */
+
+import {
+  doc,
+  getDoc,
+  setDoc,
+  updateDoc,
+  deleteDoc,
+  query,
+  where,
+  onSnapshot,
+  collection,
+  getDocs,
+} from 'firebase/firestore'
+import { getFirebaseDB } from './client'
+import type { IUserRepository } from '../../domain/interfaces/user.repository.interface'
+import type { User } from '../../domain/entities/user.entity'
+import { createRepositoryError, RepositoryErrorCode } from '../../domain/errors/repository.errors'
+
+export class FirestoreAdapter implements IUserRepository {
+  private get db() {
+    return getFirebaseDB()
+  }
+
+  private readonly USERS_COLLECTION = 'users'
+
+  async getUser(userId: string): Promise<User | null> {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId)
+      const snap = await getDoc(docRef)
+
+      if (!snap.exists()) {
+        return null
+      }
+
+      return snap.data() as User
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.DOCUMENT_NOT_FOUND, 'User not found', error)
+    }
+  }
+
+  async getUserByEmail(email: string): Promise<User | null> {
+    try {
+      const q = query(collection(this.db, this.USERS_COLLECTION), where('profile.email', '==', email))
+      const snap = await getDocs(q)
+
+      if (snap.empty) {
+        return null
+      }
+
+      const doc = snap.docs[0]
+      return doc.data() as User
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.QUERY_FAILED, 'Failed to query user', error)
+    }
+  }
+
+  async createUser(userId: string, data: Partial<User>): Promise<void> {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId)
+      await setDoc(docRef, data, { merge: true })
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.DOCUMENT_INVALID, 'Failed to create user', error)
+    }
+  }
+
+  async updateUser(userId: string, data: Partial<User>): Promise<void> {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId)
+      await updateDoc(docRef, {
+        ...data,
+        'profile.updatedAt': Date.now(),
+      } as any)
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.DOCUMENT_NOT_FOUND, 'Failed to update user', error)
+    }
+  }
+
+  async deleteUser(userId: string): Promise<void> {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId)
+      await deleteDoc(docRef)
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.DOCUMENT_NOT_FOUND, 'Failed to delete user', error)
+    }
+  }
+
+  async updateProfile(
+    userId: string,
+    updates: Partial<Pick<User['profile'], 'displayName' | 'photoURL' | 'phoneNumber'>>
+  ): Promise<void> {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId)
+      const updateData: any = {
+        'profile.updatedAt': Date.now(),
+      }
+
+      if (updates.displayName !== undefined) {
+        updateData['profile.displayName'] = updates.displayName
+      }
+      if (updates.photoURL !== undefined) {
+        updateData['profile.photoURL'] = updates.photoURL
+      }
+      if (updates.phoneNumber !== undefined) {
+        updateData['profile.phoneNumber'] = updates.phoneNumber
+      }
+
+      await updateDoc(docRef, updateData)
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.DOCUMENT_NOT_FOUND, 'Failed to update profile', error)
+    }
+  }
+
+  async updateSettings(userId: string, settings: Partial<User['settings']>): Promise<void> {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId)
+      await updateDoc(docRef, {
+        settings: {
+          ...settings,
+          updatedAt: Date.now(),
+        },
+      } as any)
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.DOCUMENT_NOT_FOUND, 'Failed to update settings', error)
+    }
+  }
+
+  async updateSubscription(userId: string, subscription: Partial<User['subscription']>): Promise<void> {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId)
+      await updateDoc(docRef, {
+        subscription: {
+          ...subscription,
+          updatedAt: Date.now(),
+        },
+      } as any)
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.DOCUMENT_NOT_FOUND, 'Failed to update subscription', error)
+    }
+  }
+
+  async updateLastLogin(userId: string): Promise<void> {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId)
+      await updateDoc(docRef, {
+        'profile.lastLoginAt': Date.now(),
+      } as any)
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.DOCUMENT_NOT_FOUND, 'Failed to update last login', error)
+    }
+  }
+
+  async queryUsers(constraints: any[]): Promise<User[]> {
+    try {
+      const q = query(collection(this.db, this.USERS_COLLECTION), ...constraints)
+      const snap = await getDocs(q)
+      return snap.docs.map((doc) => doc.data() as User)
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.QUERY_FAILED, 'Failed to query users', error)
+    }
+  }
+
+  subscribeToUser(
+    userId: string,
+    callback: (user: User | null) => void,
+    onError?: (error: Error) => void
+  ): () => void {
+    const docRef = doc(this.db, this.USERS_COLLECTION, userId)
+
+    const unsubscribe = onSnapshot(
+      docRef,
+      (snap) => {
+        if (snap.exists()) {
+          callback(snap.data() as User)
+        } else {
+          callback(null)
+        }
+      },
+      (error) => {
+        onError?.(error as Error)
+      }
+    )
+
+    return unsubscribe
+  }
+}

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

@@ -0,0 +1,323 @@
+/**
+ * Storage Adapter
+ * @description Firebase Storage implementation of IFileRepository
+ * Migrated from: /Users/umituz/Desktop/github/umituz/apps/web/app-growth-factory/src/domains/firebase/services/storage.ts
+ */
+
+import {
+  ref,
+  uploadBytes,
+  uploadBytesResumable,
+  getDownloadURL,
+  deleteObject,
+  listAll,
+  getMetadata,
+} from 'firebase/storage'
+import { getFirebaseStorage } from './client'
+import type { IFileRepository } from '../../domain/interfaces/file.repository.interface'
+import type {
+  FileMetadata,
+  UploadProgress,
+  UploadResult,
+  UploadOptions,
+  StorageStats,
+} from '../../domain/entities/file.entity'
+import { createRepositoryError, RepositoryErrorCode } from '../../domain/errors/repository.errors'
+
+export class StorageAdapter implements IFileRepository {
+  private get storage() {
+    return getFirebaseStorage()
+  }
+
+  // Upload Methods
+
+  async uploadFile(
+    userId: string,
+    path: string,
+    file: File | Blob,
+    options?: UploadOptions
+  ): Promise<UploadResult> {
+    const storageRef = ref(this.storage, `users/${userId}/${path}`)
+    const uploadTask = uploadBytesResumable(storageRef, file)
+
+    return new Promise((resolve, reject) => {
+      uploadTask.on(
+        'state_changed',
+        (snapshot) => {
+          if (options?.onProgress) {
+            const progress: UploadProgress = {
+              bytesTransferred: snapshot.bytesTransferred,
+              totalBytes: snapshot.totalBytes,
+              progress: (snapshot.bytesTransferred / snapshot.totalBytes) * 100,
+              state: 'running',
+            }
+            options.onProgress(progress)
+          }
+        },
+        (error) => reject(createRepositoryError(RepositoryErrorCode.STORAGE_ERROR, 'Upload failed', error)),
+        async () => {
+          const downloadURL = await getDownloadURL(uploadTask.snapshot.ref)
+          const metadata = await getMetadata(uploadTask.snapshot.ref)
+
+          resolve({
+            id: uploadTask.snapshot.ref.name,
+            name: metadata.name || uploadTask.snapshot.ref.name,
+            fullPath: metadata.fullPath || uploadTask.snapshot.ref.fullPath,
+            downloadURL,
+            contentType: metadata.contentType || '',
+            size: metadata.size || 0,
+            createdAt: metadata.timeCreated ? new Date(metadata.timeCreated).getTime() : Date.now(),
+          })
+        }
+      )
+    })
+  }
+
+  async uploadImage(userId: string, file: File, filename?: string): Promise<UploadResult> {
+    const name = filename || `${Date.now()}_${file.name}`
+    return this.uploadFile(userId, `images/${name}`, file)
+  }
+
+  async uploadVideo(userId: string, file: File, filename?: string): Promise<UploadResult> {
+    const name = filename || `${Date.now()}_${file.name}`
+    return this.uploadFile(userId, `videos/${name}`, file)
+  }
+
+  async uploadDocument(userId: string, file: File, filename?: string): Promise<UploadResult> {
+    const name = filename || `${Date.now()}_${file.name}`
+    return this.uploadFile(userId, `documents/${name}`, file)
+  }
+
+  async uploadProfilePicture(userId: string, file: File): Promise<UploadResult> {
+    const storageRef = ref(this.storage, `users/${userId}/profile/${Date.now()}_${file.name}`)
+    await uploadBytes(storageRef, file)
+    const downloadURL = await getDownloadURL(storageRef)
+
+    return {
+      id: storageRef.name,
+      name: file.name,
+      fullPath: storageRef.fullPath,
+      downloadURL,
+      contentType: file.type,
+      size: file.size,
+      createdAt: Date.now(),
+    }
+  }
+
+  // Download Methods
+
+  async getDownloadURL(path: string): Promise<string> {
+    try {
+      const storageRef = ref(this.storage, path)
+      return await getDownloadURL(storageRef)
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.FILE_NOT_FOUND, 'File not found', error)
+    }
+  }
+
+  // Delete Methods
+
+  async deleteFile(path: string): Promise<void> {
+    try {
+      const storageRef = ref(this.storage, path)
+      await deleteObject(storageRef)
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.FILE_NOT_FOUND, 'File not found', error)
+    }
+  }
+
+  async deleteUserFiles(userId: string): Promise<void> {
+    try {
+      const userRef = ref(this.storage, `users/${userId}`)
+      const result = await listAll(userRef)
+
+      // Delete all files in all prefixes
+      for (const prefix of result.prefixes) {
+        const prefixResult = await listAll(prefix)
+        await Promise.all(prefixResult.items.map((item) => deleteObject(item)))
+      }
+
+      // Delete all files in root
+      await Promise.all(result.items.map((item) => deleteObject(item)))
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.STORAGE_ERROR, 'Failed to delete user files', error)
+    }
+  }
+
+  async deleteImage(userId: string, filename: string): Promise<void> {
+    await this.deleteFile(`users/${userId}/images/${filename}`)
+  }
+
+  async deleteVideo(userId: string, filename: string): Promise<void> {
+    await this.deleteFile(`users/${userId}/videos/${filename}`)
+  }
+
+  async deleteProfilePicture(userId: string, filename: string): Promise<void> {
+    await this.deleteFile(`users/${userId}/profile/${filename}`)
+  }
+
+  // List Methods
+
+  async listUserFiles(userId: string, path?: string): Promise<string[]> {
+    const userRef = ref(this.storage, path ? `users/${userId}/${path}` : `users/${userId}`)
+    const result = await listAll(userRef)
+
+    const urls = await Promise.all(result.items.map((item) => getDownloadURL(item)))
+    return urls
+  }
+
+  async listUserImages(userId: string): Promise<string[]> {
+    return this.listUserFiles(userId, 'images')
+  }
+
+  async listUserVideos(userId: string): Promise<string[]> {
+    return this.listUserFiles(userId, 'videos')
+  }
+
+  // Metadata
+
+  async getFileMetadata(path: string): Promise<FileMetadata> {
+    try {
+      const storageRef = ref(this.storage, path)
+      const metadata = await getMetadata(storageRef)
+
+      return {
+        id: storageRef.name,
+        name: metadata.name,
+        fullPath: metadata.fullPath,
+        contentType: metadata.contentType || 'application/octet-stream',
+        size: metadata.size,
+        createdAt: metadata.timeCreated ? new Date(metadata.timeCreated).getTime() : Date.now(),
+        updatedAt: metadata.updated ? new Date(metadata.updated).getTime() : Date.now(),
+        userId: this.extractUserId(path) || 'unknown',
+        type: this.extractFileType(metadata.contentType || ''),
+      }
+    } catch (error) {
+      throw createRepositoryError(RepositoryErrorCode.FILE_NOT_FOUND, 'File not found', error)
+    }
+  }
+
+  async queryFiles(userId: string, _filters?: any): Promise<{ files: FileMetadata[]; totalCount: number; hasMore: boolean }> {
+    const userRef = ref(this.storage, `users/${userId}`)
+    const result = await listAll(userRef)
+
+    const files = await Promise.all(
+      result.items.map(async (item) => {
+        const metadata = await getMetadata(item)
+        return {
+          id: item.name,
+          name: metadata.name,
+          fullPath: metadata.fullPath,
+          contentType: metadata.contentType || 'application/octet-stream',
+          size: metadata.size,
+          createdAt: metadata.timeCreated ? new Date(metadata.timeCreated).getTime() : Date.now(),
+          updatedAt: metadata.updated ? new Date(metadata.updated).getTime() : Date.now(),
+          userId,
+          type: this.extractFileType(metadata.contentType || ''),
+        }
+      })
+    )
+
+    return {
+      files,
+      totalCount: files.length,
+      hasMore: false,
+    }
+  }
+
+  async getStorageStats(userId: string): Promise<StorageStats> {
+    const { files, totalCount } = await this.queryFiles(userId)
+
+    const stats: StorageStats = {
+      totalFiles: totalCount,
+      totalSize: files.reduce((sum, file) => sum + file.size, 0),
+      filesByType: {
+        image: 0,
+        video: 0,
+        audio: 0,
+        document: 0,
+        other: 0,
+      },
+      filesByCategory: {
+        profile: 0,
+        content: 0,
+        document: 0,
+        attachment: 0,
+        backup: 0,
+      },
+    }
+
+    files.forEach((file) => {
+      stats.filesByType[file.type]++
+      stats.lastUploadAt = Math.max(stats.lastUploadAt || 0, file.createdAt)
+    })
+
+    return stats
+  }
+
+  // Validation
+
+  validateFile(file: File, options?: { maxSizeBytes?: number; maxSizeMB?: number; allowedTypes?: string[] }): boolean {
+    const maxSizeBytes = options?.maxSizeBytes || (options?.maxSizeMB ? options.maxSizeMB * 1024 * 1024 : 10 * 1024 * 1024)
+
+    if (file.size > maxSizeBytes) {
+      return false
+    }
+
+    if (options?.allowedTypes && !options.allowedTypes.includes(file.type)) {
+      return false
+    }
+
+    return true
+  }
+
+  isImageFile(file: File): boolean {
+    return file.type.startsWith('image/')
+  }
+
+  isVideoFile(file: File): boolean {
+    return file.type.startsWith('video/')
+  }
+
+  isDocumentFile(file: File): boolean {
+    const docTypes = [
+      'application/pdf',
+      'application/msword',
+      'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      'application/vnd.ms-excel',
+      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      'text/plain',
+    ]
+    return docTypes.includes(file.type)
+  }
+
+  // Utility Methods
+
+  generateUniqueFilename(originalName: string): string {
+    const timestamp = Date.now()
+    const random = Math.random().toString(36).substring(2, 8)
+    const extension = this.getFileExtension(originalName)
+    return `${timestamp}_${random}.${extension}`
+  }
+
+  getFileExtension(filename: string): string {
+    return filename.slice(((filename.lastIndexOf('.') - 1) >>> 0) + 2)
+  }
+
+  // Helper Methods
+
+  private extractUserId(path: string): string {
+    const match = path.match(/users\/([^\/]+)/)
+    return match ? match[1] : ''
+  }
+
+  private extractFileType(contentType: string): 'image' | 'video' | 'audio' | 'document' | 'other' {
+    if (contentType.startsWith('image/')) return 'image'
+    if (contentType.startsWith('video/')) return 'video'
+    if (contentType.startsWith('audio/')) return 'audio'
+    if (contentType.includes('pdf') || contentType.includes('document') || contentType.includes('text')) {
+      return 'document'
+    }
+    return 'other'
+  }
+}

package/src/infrastructure/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Infrastructure Layer Public API
+ * @description Exports all Firebase adapters and repositories
+ */
+
+// Firebase
+export * from './firebase/client'
+export * from './firebase/auth.adapter'
+export * from './firebase/firestore.adapter'
+export * from './firebase/storage.adapter'
+
+// Utils
+export * from './utils/storage.util'

package/src/infrastructure/services/firebase.service.ts

@@ -0,0 +1,30 @@
+import { initializeApp, getApps, type FirebaseOptions, type FirebaseApp } from 'firebase/app';
+import { getAuth, type Auth } from 'firebase/auth';
+import { getFirestore, type Firestore } from 'firebase/firestore';
+import { getStorage, type FirebaseStorage } from 'firebase/storage';
+import { getFunctions, type Functions } from 'firebase/functions';
+
+/**
+ * Firebase Service Infrastructure
+ * @description Initialization and instance management for Firebase
+ */
+
+export interface FirebaseInstances {
+  app: FirebaseApp;
+  auth: Auth;
+  db: Firestore;
+  storage: FirebaseStorage;
+  functions: Functions;
+}
+
+export function initializeFirebase(config: FirebaseOptions, appName?: string): FirebaseInstances {
+  const existing = getApps().find((a) => a.name === (appName ?? '[DEFAULT]'));
+  const app = existing ?? initializeApp(config, appName);
+  return {
+    app,
+    auth: getAuth(app),
+    db: getFirestore(app),
+    storage: getStorage(app),
+    functions: getFunctions(app),
+  };
+}