@umituz/web-firebase 2.1.1 → 3.0.1

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'

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

@@ -0,0 +1,120 @@
+/**
+ * Storage Service Interface
+ * @description Abstract interface for storage operations
+ */
+
+import type {
+  UploadResult,
+  UploadOptions,
+} from '../entities'
+
+export interface IStorageService {
+  /**
+   * Upload file to storage
+   */
+  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<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<UploadResult>
+
+  /**
+   * Get download URL for a file
+   */
+  getDownloadURL(path: string): Promise<string>
+
+  /**
+   * Delete file by path
+   */
+  deleteFile(path: string): Promise<void>
+
+  /**
+   * Delete all user files
+   */
+  deleteUserFiles(userId: string): Promise<void>
+
+  /**
+   * Delete user image
+   */
+  deleteImage(userId: string, filename: string): Promise<void>
+
+  /**
+   * Delete user video
+   */
+  deleteVideo(userId: string, filename: string): Promise<void>
+
+  /**
+   * Delete profile picture
+   */
+  deleteProfilePicture(userId: string, filename: string): Promise<void>
+
+  /**
+   * List user files
+   */
+  listUserFiles(userId: string, path?: string): Promise<string[]>
+
+  /**
+   * List user images
+   */
+  listUserImages(userId: string): Promise<string[]>
+
+  /**
+   * List user videos
+   */
+  listUserVideos(userId: string): Promise<string[]>
+
+  /**
+   * Validate file before upload
+   */
+  validateFile(file: File, options?: {
+    maxSizeBytes?: number
+    maxSizeMB?: number
+    allowedTypes?: string[]
+  }): boolean
+
+  /**
+   * Check if file is an image
+   */
+  isImageFile(file: File): boolean
+
+  /**
+   * Check if file is a video
+   */
+  isVideoFile(file: File): boolean
+
+  /**
+   * Check if file is a document
+   */
+  isDocumentFile(file: File): boolean
+
+  /**
+   * Generate unique filename
+   */
+  generateUniqueFilename(originalName: string): string
+
+  /**
+   * Get file extension
+   */
+  getFileExtension(filename: string): string
+}

package/src/index.ts

@@ -1,23 +1,19 @@
 /**
  * @umituz/web-firebase
- * Comprehensive Firebase integration with DDD architecture
+ * Firebase integration for web applications with domain-based architecture
  *
- * ONEMLI: App'ler bu root barrel'i kullanMAMALI.
- * Subpath import kullanin:
- * - "@umituz/web-firebase/domain" - Domain entities, value objects, interfaces
- * - "@umituz/web-firebase/application" - Use cases and DTOs
- * - "@umituz/web-firebase/infrastructure" - Firebase adapters
- * - "@umituz/web-firebase/presentation" - React hooks and providers
+ * Usage:
+ * import { AuthService } from '@umituz/web-firebase/auth'
+ * import { FirestoreService } from '@umituz/web-firebase/firestore'
+ * import { StorageService } from '@umituz/web-firebase/storage'
  */
 
-// Domain entities, value objects, interfaces, errors
-export * from './domain'
+// Firebase client initialization
+export * from './infrastructure/firebase/client'
 
-// Application use cases and DTOs
-export * from './application'
+// React components
+export { FirebaseProvider, useFirebaseContext } from './presentation/providers/FirebaseProvider'
 
-// Infrastructure Firebase adapters
-export * from './infrastructure'
-
-// Presentation hooks and providers
-export * from './presentation'
+// Re-export common types for convenience
+export type { FirebaseInstances } from './infrastructure/firebase/client'
+export type { FirebaseContextValue, FirebaseProviderProps } from './presentation/providers/FirebaseProvider'

package/src/presentation/hooks/useAuth.ts

@@ -1,19 +1,19 @@
 /**
  * Auth Hook
  * @description React hook for authentication operations
- * Uses FirebaseProvider context - no repository injection needed
+ * Uses new domain services - no adapter injection needed
  */
 
-import { useCallback } from 'react'
+import { useCallback, useEffect, useState } from 'react'
 import type { User as FirebaseUser } from 'firebase/auth'
-import type { User } from '../../domain/entities/user.entity'
-import { AuthAdapter } from '../../infrastructure/firebase/auth.adapter'
-import { FirestoreAdapter } from '../../infrastructure/firebase/firestore.adapter'
+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'
 
 export interface UseAuthResult {
   firebaseUser: FirebaseUser | null
-  user: User | null
+  user: FirestoreUser | null
   loading: boolean
   error: Error | null
   isAuthenticated: boolean
@@ -29,62 +29,106 @@ export interface UseAuthResult {
 }
 
 export function useAuth(): UseAuthResult {
-  const { instances, user, loading, error } = useFirebaseContext()
-
-  const authAdapter = new AuthAdapter()
-  const firestoreAdapter = new FirestoreAdapter()
+  const { instances, loading, error } = useFirebaseContext()
+  const [user, setUser] = useState<FirestoreUser | null>(null)
+
+  useEffect(() => {
+    const fetchUser = async () => {
+      const currentUser = instances?.auth.currentUser
+      if (currentUser) {
+        const userData = await firestoreService.getUser(currentUser.uid)
+        setUser(userData)
+      } else {
+        setUser(null)
+      }
+    }
+    fetchUser()
+  }, [instances?.auth.currentUser])
 
   const signIn = useCallback(async (email: string, password: string) => {
-    return await authAdapter.signIn(email, password)
+    const result = await authService.signIn(email, password)
+    return result.user
   }, [])
 
   const signUp = useCallback(async (email: string, password: string, displayName: string) => {
-    const userCredential = await authAdapter.signUp(email, password, displayName)
+    const userCredential = await authService.signUp(email, password, displayName)
 
     // Create user profile in Firestore
-    await firestoreAdapter.createUser(userCredential.user.uid, {
+    const now = Date.now()
+    await firestoreService.createUser(userCredential.user.uid, {
       profile: {
+        id: userCredential.user.uid,
         email: email,
         displayName: displayName,
-        createdAt: Date.now(),
+        createdAt: now,
+        updatedAt: now,
+        lastLoginAt: now,
+        emailVerified: false,
       },
       settings: {
         theme: 'light',
         language: 'tr',
+        timezone: 'Europe/Istanbul',
+        currency: 'TRY',
+        notifications: {
+          email: true,
+          push: true,
+          marketing: false,
+          security: true,
+          weeklyDigest: false,
+        },
+        privacy: {
+          profileVisibility: 'public',
+          showEmail: false,
+          showPhone: false,
+          dataSharing: false,
+        },
+      },
+      subscription: {
+        plan: 'free',
+        status: 'active',
+        cancelAtPeriodEnd: false,
+        createdAt: now,
+        updatedAt: now,
       },
     })
 
     return userCredential.user
   }, [])
 
-  const signInWithGoogle = useCallback(async () => {
-    return await authAdapter.signInWithGoogle()
+  const signInWithGoogleCallback = useCallback(async () => {
+    const result = await authService.signInWithGoogle()
+    return result.user
   }, [])
 
   const signOut = useCallback(async () => {
-    await authAdapter.signOut()
+    await authService.signOut()
   }, [])
 
   const sendPasswordReset = useCallback(async (email: string) => {
-    await authAdapter.sendPasswordReset(email)
+    await authService.sendPasswordReset(email)
   }, [])
 
   const resendEmailVerification = useCallback(async () => {
-    await authAdapter.resendEmailVerification()
+    await authService.resendEmailVerification()
   }, [])
 
   const updateProfile = useCallback(async (updates: { displayName?: string; photoURL?: string }) => {
-    await authAdapter.updateProfile(updates)
+    await authService.updateProfile(updates)
 
     // Refresh user data from Firestore if available
-    if (instances?.auth.currentUser) {
-      await firestoreAdapter.getUser(instances.auth.currentUser.uid)
+    const currentUser = instances?.auth.currentUser
+    if (currentUser) {
+      const userData = await firestoreService.getUser(currentUser.uid)
+      setUser(userData)
     }
   }, [instances])
 
   const refreshUser = useCallback(async () => {
-    if (instances?.auth.currentUser) {
-      await firestoreAdapter.getUser(instances.auth.currentUser.uid)
+    const currentUser = instances?.auth.currentUser
+    if (currentUser) {
+      const userData = await firestoreService.getUser(currentUser.uid)
+      setUser(userData)
     }
   }, [instances])
 
@@ -97,7 +141,7 @@ export function useAuth(): UseAuthResult {
     isEmailVerified: instances?.auth.currentUser?.emailVerified || false,
     signIn,
     signUp,
-    signInWithGoogle,
+    signInWithGoogle: signInWithGoogleCallback,
     signOut,
     sendPasswordReset,
     resendEmailVerification,
@@ -105,4 +149,3 @@ export function useAuth(): UseAuthResult {
     refreshUser,
   }
 }
-

package/src/presentation/providers/FirebaseProvider.tsx

@@ -7,12 +7,14 @@ import { createContext, useContext, useState, useEffect, type ReactNode } from '
 import type { User } from 'firebase/auth'
 import type { FirebaseInstances } from '../../infrastructure/firebase/client'
 import { getFirebaseInstances } from '../../infrastructure/firebase/client'
-import { AuthAdapter } from '../../infrastructure/firebase/auth.adapter'
+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
 }
@@ -34,6 +36,7 @@ export interface FirebaseProviderProps {
 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)
 
@@ -44,10 +47,10 @@ export function FirebaseProvider({ children, config }: FirebaseProviderProps) {
       setInstances(firebaseInstances)
 
       // Set up auth state listener
-      const authAdapter = new AuthAdapter()
-      const unsubscribe = authAdapter.onAuthStateChanged(
-        (user) => {
-          setUser(user)
+      const unsubscribe = authService.onAuthStateChanged(
+        (newAuthUser) => {
+          setAuthUser(newAuthUser)
+          setUser(newAuthUser ? (firebaseInstances.auth.currentUser || null) : null)
           setLoading(false)
           setError(null)
         },
@@ -70,18 +73,11 @@ export function FirebaseProvider({ children, config }: FirebaseProviderProps) {
     instances: instances!,
     isInitialized: !!instances,
     user,
+    authUser,
     loading,
     error,
   }
 
-  if (!instances || loading) {
-    return (
-      <FirebaseContext.Provider value={{ ...value, isInitialized: false }}>
-        {children}
-      </FirebaseContext.Provider>
-    )
-  }
-
   return <FirebaseContext.Provider value={value}>{children}</FirebaseContext.Provider>
 }
 
@@ -92,4 +88,3 @@ export function useFirebaseContext(): FirebaseContextValue {
   }
   return context
 }
-