@umituz/web-firebase 2.1.0 → 3.0.0

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
 }
-

package/dist/application/index.d.mts

@@ -1,273 +0,0 @@
-import { UserCredential } from 'firebase/auth';
-import { c as User, I as IAuthRepository, a as IUserRepository } from '../user.repository.interface-DS74TsJ5.mjs';
-import 'firebase/firestore';
-
-/**
- * Authentication DTOs
- * @description Data Transfer Objects for authentication operations
- */
-
-/**
- * Sign In DTO
- */
-interface SignInDTO {
-    email: string;
-    password: string;
-}
-/**
- * Sign Up DTO
- */
-interface SignUpDTO {
-    email: string;
-    password: string;
-    displayName: string;
-}
-/**
- * Sign Up Result
- */
-interface SignUpResult extends UserCredential {
-    userId: string;
-    emailVerified: boolean;
-}
-/**
- * Reset Password DTO
- */
-interface ResetPasswordDTO {
-    email: string;
-}
-/**
- * Update Profile DTO
- */
-interface UpdateProfileDTO {
-    displayName?: string;
-    photoURL?: string;
-}
-/**
- * Update Email DTO
- */
-interface UpdateEmailDTO {
-    newEmail: string;
-    currentPassword: string;
-}
-/**
- * Update Password DTO
- */
-interface UpdatePasswordDTO {
-    currentPassword: string;
-    newPassword: string;
-}
-/**
- * Delete Account DTO
- */
-interface DeleteAccountDTO {
-    password: string;
-}
-
-/**
- * User DTOs
- * @description Data Transfer Objects for user operations
- */
-
-/**
- * Create User DTO
- */
-interface CreateUserDTO {
-    id: string;
-    email: string;
-    displayName: string;
-    photoURL?: string;
-    phoneNumber?: string;
-    emailVerified: boolean;
-}
-/**
- * Update User DTO
- */
-interface UpdateUserDTO {
-    displayName?: string;
-    photoURL?: string;
-    phoneNumber?: string;
-    theme?: 'light' | 'dark' | 'system';
-    language?: string;
-    timezone?: string;
-}
-/**
- * Update User Settings DTO
- */
-interface UpdateUserSettingsDTO {
-    theme?: 'light' | 'dark' | 'system';
-    language?: string;
-    timezone?: string;
-    currency?: string;
-    notifications?: Partial<User['settings']['notifications']>;
-    privacy?: Partial<User['settings']['privacy']>;
-}
-/**
- * Update User Subscription DTO
- */
-interface UpdateUserSubscriptionDTO {
-    plan?: User['subscription']['plan'];
-    status?: User['subscription']['status'];
-    polarCustomerId?: string;
-    polarSubscriptionId?: string;
-    currentPeriodStart?: number;
-    currentPeriodEnd?: number;
-    cancelAtPeriodEnd?: boolean;
-}
-/**
- * User Query Result
- */
-interface UserQueryResult {
-    user: User | null;
-    lastLoginAt?: number;
-    createdAt?: number;
-}
-
-/**
- * Sign In Use Case
- * @description Handles user sign in with email/password
- */
-
-declare class SignInUseCase {
-    private readonly authRepository;
-    constructor(authRepository: IAuthRepository);
-    /**
-     * Execute sign in use case
-     */
-    execute(dto: SignInDTO): Promise<UserCredential>;
-    /**
-     * Validate DTO
-     */
-    private validateDTO;
-    /**
-     * Handle errors
-     */
-    private handleError;
-}
-
-/**
- * Sign Up Use Case
- * @description Handles user registration with email/password
- */
-
-declare class SignUpUseCase {
-    private readonly authRepository;
-    private readonly userRepository;
-    constructor(authRepository: IAuthRepository, userRepository: IUserRepository);
-    /**
-     * Execute sign up use case
-     */
-    execute(dto: SignUpDTO): Promise<SignUpResult>;
-    /**
-     * Validate DTO
-     */
-    private validateDTO;
-    /**
-     * Handle errors
-     */
-    private handleError;
-}
-
-/**
- * Sign In With Google Use Case
- * @description Handles Google OAuth sign in/sign up
- */
-
-declare class SignInWithGoogleUseCase {
-    private readonly authRepository;
-    private readonly userRepository;
-    constructor(authRepository: IAuthRepository, userRepository: IUserRepository);
-    /**
-     * Execute Google sign in use case
-     */
-    execute(): Promise<UserCredential>;
-    /**
-     * Handle errors
-     */
-    private handleError;
-}
-
-/**
- * Reset Password Use Case
- * @description Handles password reset flow
- */
-
-declare class ResetPasswordUseCase {
-    private readonly authRepository;
-    constructor(authRepository: IAuthRepository);
-    /**
-     * Execute password reset use case
-     */
-    execute(dto: ResetPasswordDTO): Promise<void>;
-    /**
-     * Validate DTO
-     */
-    private validateDTO;
-    /**
-     * Handle errors
-     */
-    private handleError;
-}
-
-/**
- * Sign Out Use Case
- * @description Handles user sign out
- */
-
-declare class SignOutUseCase {
-    private readonly authRepository;
-    constructor(authRepository: IAuthRepository);
-    /**
-     * Execute sign out use case
-     */
-    execute(): Promise<void>;
-}
-
-/**
- * Update Profile Use Case
- * @description Handles user profile updates
- */
-
-declare class UpdateProfileUseCase {
-    private readonly authRepository;
-    constructor(authRepository: IAuthRepository);
-    /**
-     * Execute profile update use case
-     */
-    execute(dto: UpdateProfileDTO): Promise<void>;
-    /**
-     * Validate DTO
-     */
-    private validateDTO;
-    /**
-     * Validate URL format
-     */
-    private isValidURL;
-    /**
-     * Handle errors
-     */
-    private handleError;
-}
-
-/**
- * Delete Account Use Case
- * @description Handles user account deletion
- */
-
-declare class DeleteAccountUseCase {
-    private readonly authRepository;
-    constructor(authRepository: IAuthRepository);
-    /**
-     * Execute account deletion use case
-     */
-    execute(dto: DeleteAccountDTO): Promise<void>;
-    /**
-     * Validate DTO
-     */
-    private validateDTO;
-    /**
-     * Handle errors
-     */
-    private handleError;
-}
-
-export { type CreateUserDTO, type DeleteAccountDTO, DeleteAccountUseCase, type ResetPasswordDTO, ResetPasswordUseCase, type SignInDTO, SignInUseCase, SignInWithGoogleUseCase, SignOutUseCase, type SignUpDTO, type SignUpResult, SignUpUseCase, type UpdateEmailDTO, type UpdatePasswordDTO, type UpdateProfileDTO, UpdateProfileUseCase, type UpdateUserDTO, type UpdateUserSettingsDTO, type UpdateUserSubscriptionDTO, type UserQueryResult };