@umituz/web-firebase 2.1.1 → 3.0.0

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

@@ -0,0 +1,191 @@
+/**
+ * Firestore Service
+ * @description Firebase Firestore implementation of IFirestoreService
+ */
+
+import {
+  doc,
+  getDoc,
+  setDoc,
+  updateDoc,
+  deleteDoc,
+  query,
+  where,
+  onSnapshot,
+  collection,
+  getDocs,
+} from 'firebase/firestore'
+import { getFirebaseDB } from '../../../infrastructure/firebase/client'
+import type { IFirestoreService } from '../types'
+import type { User } from '../entities'
+
+class FirestoreService implements IFirestoreService {
+  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 new Error('User not found')
+    }
+  }
+
+  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 new Error('Failed to query user')
+    }
+  }
+
+  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 new Error('Failed to create user')
+    }
+  }
+
+  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 new Error('Failed to update user')
+    }
+  }
+
+  async deleteUser(userId: string): Promise<void> {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId)
+      await deleteDoc(docRef)
+    } catch (error) {
+      throw new Error('Failed to delete user')
+    }
+  }
+
+  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 new Error('Failed to update profile')
+    }
+  }
+
+  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 new Error('Failed to update settings')
+    }
+  }
+
+  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 new Error('Failed to update subscription')
+    }
+  }
+
+  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 new Error('Failed to update last login')
+    }
+  }
+
+  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 new Error('Failed to query users')
+    }
+  }
+
+  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
+  }
+}
+
+// Export class and singleton instance
+export const firestoreService = new FirestoreService()

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

@@ -0,0 +1,7 @@
+/**
+ * Firestore Domain Services
+ * Subpath: @umituz/web-firebase/firestore
+ */
+
+export { firestoreService } from './firestore.service'
+export type { IFirestoreService } from '../types'

package/src/domains/firestore/types/firestore-service.interface.ts

@@ -0,0 +1,64 @@
+/**
+ * Firestore Service Interface
+ * @description Abstract interface for Firestore operations
+ */
+
+import type { QueryConstraint } from 'firebase/firestore'
+import type { User } from '../entities'
+
+export interface IFirestoreService {
+  /**
+   * Get user by ID
+   */
+  getUser(userId: string): Promise<User | null>
+
+  /**
+   * Get user by email
+   */
+  getUserByEmail(email: string): Promise<User | null>
+
+  /**
+   * Create user
+   */
+  createUser(userId: string, data: Partial<User>): Promise<void>
+
+  /**
+   * Update user
+   */
+  updateUser(userId: string, data: Partial<User>): Promise<void>
+
+  /**
+   * Delete user
+   */
+  deleteUser(userId: string): Promise<void>
+
+  /**
+   * Update user profile
+   */
+  updateProfile(userId: string, updates: Partial<Pick<User['profile'], 'displayName' | 'photoURL' | 'phoneNumber'>>): Promise<void>
+
+  /**
+   * Update user settings
+   */
+  updateSettings(userId: string, settings: Partial<User['settings']>): Promise<void>
+
+  /**
+   * Update user subscription
+   */
+  updateSubscription(userId: string, subscription: Partial<User['subscription']>): Promise<void>
+
+  /**
+   * Update last login timestamp
+   */
+  updateLastLogin(userId: string): Promise<void>
+
+  /**
+   * Query users with constraints
+   */
+  queryUsers(constraints: QueryConstraint[]): Promise<User[]>
+
+  /**
+   * Subscribe to user document changes
+   */
+  subscribeToUser(userId: string, callback: (user: User | null) => void, onError?: (error: Error) => void): () => void
+}

package/src/domains/firestore/types/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Firestore Domain Types
+ */
+
+export * from './firestore-service.interface'

package/src/domains/storage/entities/index.ts

@@ -0,0 +1,94 @@
+/**
+ * Storage Domain Entities
+ * @description File and storage-related entities
+ */
+
+/**
+ * File Metadata Entity
+ * Contains metadata about uploaded files
+ */
+export interface FileMetadata {
+  readonly id: string
+  readonly name: string
+  readonly fullPath: string
+  readonly contentType: string
+  readonly size: number
+  readonly createdAt: number
+  readonly updatedAt: number
+  readonly userId: string
+  readonly type: FileType
+  category?: FileCategory
+  description?: string
+  tags?: string[]
+}
+
+/**
+ * File Types
+ */
+export type FileType = 'image' | 'video' | 'audio' | 'document' | 'other'
+
+/**
+ * File Categories
+ */
+export type FileCategory = 'profile' | 'content' | 'document' | 'attachment' | 'backup'
+
+/**
+ * Upload Progress Entity
+ * Tracks upload progress for resumable uploads
+ */
+export interface UploadProgress {
+  bytesTransferred: number
+  totalBytes: number
+  progress: number // 0-100
+  state: UploadState
+  speed?: number // bytes per second
+  remaining?: number // seconds remaining
+}
+
+/**
+ * Upload States
+ */
+export type UploadState =
+  | 'paused'
+  | 'running'
+  | 'success'
+  | 'canceled'
+  | 'error'
+
+/**
+ * File Upload Result Entity
+ * Result of a file upload operation
+ */
+export interface FileUploadResult {
+  readonly id: string
+  readonly name: string
+  readonly fullPath: string
+  readonly downloadURL: string
+  readonly contentType: string
+  readonly size: number
+  readonly createdAt: number
+}
+
+// Export as UploadResult for backward compatibility
+export type UploadResult = FileUploadResult
+
+/**
+ * Upload Options
+ * Configuration for file uploads
+ */
+export interface UploadOptions {
+  onProgress?: (progress: UploadProgress) => void
+  metadata?: FileMetadata
+  customMetadata?: Record<string, string>
+}
+
+/**
+ * Storage Statistics
+ */
+export interface StorageStats {
+  totalFiles: number
+  totalSize: number
+  filesByType: Record<FileType, number>
+  filesByCategory: Record<FileCategory, number>
+  lastUploadAt?: number
+}

package/src/domains/storage/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Storage Domain
+ * Complete Firebase Storage integration
+ */
+
+// Entities
+export * from './entities'
+
+// Types
+export * from './types'
+
+// Services
+export * from './services'

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

@@ -0,0 +1,7 @@
+/**
+ * Storage Domain Services
+ * Subpath: @umituz/web-firebase/storage
+ */
+
+export { storageService } from './storage.service'
+export type { IStorageService } from '../types'

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

@@ -0,0 +1,223 @@
+/**
+ * Storage Service
+ * @description Firebase Storage implementation of IStorageService
+ */
+
+import {
+  ref,
+  uploadBytes,
+  uploadBytesResumable,
+  getDownloadURL,
+  deleteObject,
+  listAll,
+  getMetadata,
+} from 'firebase/storage'
+import { getFirebaseStorage } from '../../../infrastructure/firebase/client'
+import type { IStorageService } from '../types'
+import type {
+  UploadResult,
+  UploadOptions,
+} from '../entities'
+
+class StorageService implements IStorageService {
+  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 = {
+              bytesTransferred: snapshot.bytesTransferred,
+              totalBytes: snapshot.totalBytes,
+              progress: (snapshot.bytesTransferred / snapshot.totalBytes) * 100,
+              state: 'running' as const,
+            }
+            options.onProgress(progress)
+          }
+        },
+        () => reject(new Error('Upload failed')),
+        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 {
+      throw new Error('File not found')
+    }
+  }
+
+  // Delete Methods
+
+  async deleteFile(path: string): Promise<void> {
+    try {
+      const storageRef = ref(this.storage, path)
+      await deleteObject(storageRef)
+    } catch {
+      throw new Error('File not found')
+    }
+  }
+
+  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 {
+      throw new Error('Failed to delete user files')
+    }
+  }
+
+  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')
+  }
+
+  // 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)
+  }
+}
+
+// Export class and singleton instance
+export const storageService = new StorageService()

package/src/domains/storage/types/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Storage Domain Types
+ */
+
+export * from './storage-service.interface'