@umituz/web-firebase 3.0.0 → 3.2.0

package/README.md

@@ -11,6 +11,10 @@ Comprehensive Firebase integration with Domain-Driven Design (DDD) architecture
 - ✅ **React Hooks** - Ready-to-use presentation layer hooks
 - ✅ **Error Handling** - Domain-specific error types
 - ✅ **Zero Code Duplication** - Package-driven development ready
+- ✅ **Google & Apple OAuth** - Built-in support for Google Sign-In and Apple Sign-In
+- ✅ **Configurable Auth** - Enable/disable providers, configure scopes and custom parameters
+- ✅ **Auto User Document Creation** - Automatic Firestore user document creation with custom settings
+- ✅ **Provider Linking/Unlinking** - Link multiple auth providers to a single account
 
 ## 📦 Installation
 
@@ -64,6 +68,61 @@ const firebaseConfig = {
 initializeFirebaseApp(firebaseConfig)
 ```
 
+### 2. Configure Authentication
+
+```typescript
+import { initAuthConfig } from '@umituz/web-firebase/config'
+
+// Initialize auth configuration
+initAuthConfig({
+  // Enable/disable email/password authentication
+  emailPasswordEnabled: true,
+
+  // Enable/disable OAuth providers
+  googleEnabled: true,
+  appleEnabled: true,
+
+  // Configure Google OAuth
+  googleScopes: ['profile', 'email'],
+  googleCustomParameters: {
+    prompt: 'select_account',
+  },
+
+  // Require email verification for new users
+  requireEmailVerification: true,
+
+  // Automatically create user document in Firestore
+  autoCreateUserDocument: true,
+
+  // Default user settings
+  defaultUserSettings: {
+    theme: 'system',
+    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,
+    },
+  },
+
+  // Default subscription plan
+  defaultSubscriptionPlan: 'free',
+
+  // Session persistence
+  persistence: 'local',
+})
+```
+
 ### 2. Use Domain Layer (Types & Interfaces)
 
 ```typescript
@@ -231,6 +290,28 @@ const credential = await auth.signUp('user@example.com', 'password', 'John Doe')
 // Sign in with Google
 const credential = await auth.signInWithGoogle()
 
+// Sign in with Apple
+const credential = await auth.signInWithApple()
+
+// Sign in with redirect flow (for mobile/better UX)
+const credential = await auth.signInWithGoogle(true) // useRedirect = true
+
+// Link Google to current user
+await auth.linkGoogle()
+
+// Link Apple to current user
+await auth.linkApple()
+
+// Unlink a provider
+await auth.unlinkProvider('google.com')
+
+// Get ID token (for API calls)
+const token = await auth.getIdToken()
+const tokenForceRefresh = await auth.getIdToken(true)
+
+// Refresh ID token
+await auth.refreshToken()
+
 // Sign out
 await auth.signOut()
 
@@ -385,40 +466,100 @@ import {
 } from '@umituz/web-firebase/presentation'
 
 function MyComponent() {
-  // Auth hook
+  // Auth hook with Google & Apple OAuth
   const {
-    user: firebaseUser,
+    firebaseUser,
     user: userData,
     loading,
     error,
+    // Email/Password
     signIn,
     signUp,
+    // OAuth Providers
     signInWithGoogle,
+    signInWithApple,
+    // Provider management
+    linkGoogle,
+    linkApple,
+    unlinkProvider,
+    // Account management
     signOut,
-  } = useAuth({
-    authRepository: new AuthAdapter(),
-    userRepository: new FirestoreAdapter(),
-  })
-
-  // User hook
-  const { user, loading: userLoading } = useUser({
-    userRepository: new FirestoreAdapter(),
-    userId: firebaseUser?.uid,
-  })
+    sendPasswordReset,
+    resendEmailVerification,
+    updateProfile,
+    updateEmail,
+    updatePassword,
+    deleteAccount,
+    // Token management
+    getIdToken,
+    refreshToken,
+    // User data
+    refreshUser,
+    // Config
+    googleEnabled,
+    appleEnabled,
+    emailPasswordEnabled,
+  } = useAuth()
+
+  // Example: Sign in with Google
+  const handleGoogleSignIn = async () => {
+    try {
+      const user = await signInWithGoogle()
+      console.log('Signed in with Google:', user)
+    } catch (error) {
+      console.error('Sign in failed:', error)
+    }
+  }
+
+  // Example: Sign in with Apple
+  const handleAppleSignIn = async () => {
+    try {
+      const user = await signInWithApple()
+      console.log('Signed in with Apple:', user)
+    } catch (error) {
+      console.error('Sign in failed:', error)
+    }
+  }
+
+  // Example: Get ID token for API call
+  const makeApiCall = async () => {
+    const token = await getIdToken()
+    const response = await fetch('/api/protected', {
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    })
+    return response.json()
+  }
 
-  // Storage hook
-  const {
-    uploadFile,
-    uploadImage,
-    uploadProfilePicture,
-    deleteFile,
-    uploading,
-    progress,
-    error: storageError,
-  } = useStorage({
-    fileRepository: new StorageAdapter(),
-    userId: firebaseUser?.uid,
-  })
+  return (
+    <div>
+      {loading ? (
+        <p>Loading...</p>
+      ) : firebaseUser ? (
+        <>
+          <p>Welcome, {userData?.profile.displayName}</p>
+          <button onClick={handleGoogleSignIn}>Re-authenticate with Google</button>
+          <button onClick={() => linkApple()}>Link Apple Account</button>
+          <button onClick={() => signOut()}>Sign Out</button>
+        </>
+      ) : (
+        <>
+          {emailPasswordEnabled && (
+            <button onClick={() => signIn('user@example.com', 'password')}>
+              Sign In with Email
+            </button>
+          )}
+          {googleEnabled && (
+            <button onClick={handleGoogleSignIn}>Sign In with Google</button>
+          )}
+          {appleEnabled && (
+            <button onClick={handleAppleSignIn}>Sign In with Apple</button>
+          )}
+        </>
+      )}
+    </div>
+  )
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/web-firebase",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "description": "Comprehensive Firebase integration with domain-based architecture for web applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -13,6 +13,8 @@
     "./auth": "./src/domains/auth/index.ts",
     "./firestore": "./src/domains/firestore/index.ts",
     "./storage": "./src/domains/storage/index.ts",
+    "./domain": "./src/domain/index.ts",
+    "./config": "./src/domain/config/auth.config.ts",
     "./package.json": "./package.json"
   },
   "files": [

package/src/domain/config/auth.config.ts

@@ -0,0 +1,200 @@
+/**
+ * Auth Configuration
+ * @description Configuration options for Firebase Authentication
+ * Following DDD principles, this is a domain configuration value object
+ */
+
+/**
+ * Available OAuth Providers
+ */
+export type OAuthProviderType =
+  | 'google'
+  | 'apple'
+
+/**
+ * OAuth Provider Configuration
+ */
+export interface OAuthProviderConfig {
+  enabled: boolean
+  scopes?: string[]
+  customParameters?: Record<string, string>
+}
+
+/**
+ * Auth Configuration Interface
+ */
+export interface AuthConfig {
+  // Email/Password Authentication
+  emailPasswordEnabled: boolean
+
+  // OAuth Providers
+  // OAuth Providers (Google & Apple)
+  googleEnabled: boolean
+  appleEnabled: boolean
+  googleScopes?: string[]
+  googleCustomParameters?: Record<string, string>
+
+  // Email Verification
+  requireEmailVerification: boolean
+
+  // User Document Creation
+  autoCreateUserDocument: boolean
+
+  // Default User Settings (applied when creating user document)
+  defaultUserSettings?: {
+    theme?: 'light' | 'dark' | 'system'
+    language?: string
+    timezone?: string
+    currency?: string
+    notifications?: {
+      email?: boolean
+      push?: boolean
+      marketing?: boolean
+      security?: boolean
+      weeklyDigest?: boolean
+    }
+    privacy?: {
+      profileVisibility?: 'public' | 'private'
+      showEmail?: boolean
+      showPhone?: boolean
+      dataSharing?: boolean
+    }
+  }
+
+  // Default Subscription Plan
+  defaultSubscriptionPlan?: 'free' | 'standard' | 'professional' | 'business'
+
+  // Token Refresh Settings
+  tokenRefreshEnabled: boolean
+  tokenRefreshThreshold: number // milliseconds
+
+  // Session Persistence
+  persistence: 'local' | 'session' | 'none'
+
+  // Error Handling
+  throwOnAuthError: boolean
+}
+
+/**
+ * Default Auth Configuration
+ */
+export const DEFAULT_AUTH_CONFIG: AuthConfig = {
+  emailPasswordEnabled: true,
+  googleEnabled: true,
+  appleEnabled: false,
+  googleScopes: ['profile', 'email'],
+  requireEmailVerification: true,
+  autoCreateUserDocument: true,
+  defaultUserSettings: {
+    theme: 'system',
+    language: 'en',
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    currency: 'USD',
+    notifications: {
+      email: true,
+      push: true,
+      marketing: false,
+      security: true,
+      weeklyDigest: false,
+    },
+    privacy: {
+      profileVisibility: 'public',
+      showEmail: false,
+      showPhone: false,
+      dataSharing: false,
+    },
+  },
+  defaultSubscriptionPlan: 'free',
+  tokenRefreshEnabled: true,
+  tokenRefreshThreshold: 5 * 60 * 1000, // 5 minutes
+  persistence: 'local',
+  throwOnAuthError: true,
+}
+
+/**
+ * Auth Configuration Manager
+ * Singleton class to manage auth configuration
+ */
+export class AuthConfigManager {
+  private static instance: AuthConfigManager
+  private config: AuthConfig
+
+  private constructor(config: Partial<AuthConfig> = {}) {
+    this.config = {
+      ...DEFAULT_AUTH_CONFIG,
+      ...config,
+      defaultUserSettings: {
+        ...DEFAULT_AUTH_CONFIG.defaultUserSettings,
+        ...config.defaultUserSettings,
+        notifications: {
+          ...DEFAULT_AUTH_CONFIG.defaultUserSettings?.notifications,
+          ...config.defaultUserSettings?.notifications,
+        },
+        privacy: {
+          ...DEFAULT_AUTH_CONFIG.defaultUserSettings?.privacy,
+          ...config.defaultUserSettings?.privacy,
+        },
+      },
+    }
+  }
+
+  static getInstance(config?: Partial<AuthConfig>): AuthConfigManager {
+    if (!AuthConfigManager.instance) {
+      AuthConfigManager.instance = new AuthConfigManager(config)
+    }
+    return AuthConfigManager.instance
+  }
+
+  getConfig(): AuthConfig {
+    return { ...this.config }
+  }
+
+  updateConfig(updates: Partial<AuthConfig>): void {
+    this.config = {
+      ...this.config,
+      ...updates,
+      defaultUserSettings: {
+        ...this.config.defaultUserSettings,
+        ...updates.defaultUserSettings,
+        notifications: {
+          ...this.config.defaultUserSettings?.notifications,
+          ...updates.defaultUserSettings?.notifications,
+        },
+        privacy: {
+          ...this.config.defaultUserSettings?.privacy,
+          ...updates.defaultUserSettings?.privacy,
+        },
+      },
+    }
+  }
+
+  isGoogleEnabled(): boolean {
+    return this.config.googleEnabled
+  }
+
+  isAppleEnabled(): boolean {
+    return this.config.appleEnabled
+  }
+
+  isEmailPasswordEnabled(): boolean {
+    return this.config.emailPasswordEnabled
+  }
+
+  shouldCreateUserDocument(): boolean {
+    return this.config.autoCreateUserDocument
+  }
+}
+
+/**
+ * Initialize Auth Config with custom settings
+ */
+export function initAuthConfig(config: Partial<AuthConfig> = {}): AuthConfigManager {
+  return AuthConfigManager.getInstance(config)
+}
+
+/**
+ * Get Auth Config instance
+ */
+export function getAuthConfig(): AuthConfigManager {
+  return AuthConfigManager.getInstance()
+}

package/src/domain/index.ts

@@ -28,3 +28,6 @@ export * from './interfaces/file.repository.interface'
 // Errors
 export * from './errors/auth.errors'
 export * from './errors/repository.errors'
+
+// Config
+export * from './config/auth.config'

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

@@ -1,15 +1,10 @@
 /**
  * Authentication Repository Interface
- * @description Defines contract for authentication operations
+ * @description Generic contract for authentication operations
  */
 
-import type { User as FirebaseUser, UserCredential } from 'firebase/auth'
-import type { User } from '../entities/user.entity'
+import type { UserCredential, User as FirebaseUser } from 'firebase/auth'
 
-/**
- * Authentication Repository Interface
- * Defines operations for user authentication and management
- */
 export interface IAuthRepository {
   /**
    * Sign in with email and password
@@ -44,7 +39,7 @@ export interface IAuthRepository {
   /**
    * Update user profile (displayName, photoURL)
    */
-  updateProfile(updates: Partial<Pick<User['profile'], 'displayName' | 'photoURL'>>): Promise<void>
+  updateProfile(updates: { displayName?: string; photoURL?: string }): Promise<void>
 
   /**
    * Update user email (requires password)
@@ -69,15 +64,5 @@ export interface IAuthRepository {
   /**
    * Subscribe to auth state changes
    */
-  onAuthStateChanged(callback: (user: FirebaseUser | null) => void): () => void
-
-  /**
-   * Create user document in Firestore
-   */
-  createUserDocument(userId: string, data: Partial<Omit<User, 'profile'>> & { email: string; displayName: string }): Promise<void>
-
-  /**
-   * Update last login timestamp
-   */
-  updateLastLogin(userId: string): Promise<void>
+  onAuthStateChanged(callback: (user: FirebaseUser | null) => void, onError?: (error: Error) => void): () => void
 }

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

@@ -1,51 +1,23 @@
 /**
  * File Repository Interface
- * @description Defines contract for file storage operations
+ * @description Generic contract for file storage operations
  */
 
-import type {
-  FileMetadata,
-  UploadResult,
-  UploadOptions,
-  FileFilters,
-  FileQueryResult,
-  StorageStats,
-} from '../entities/file.entity'
-
-/**
- * File Repository Interface
- * Defines operations for file storage and management
- */
 export interface IFileRepository {
   /**
    * Upload file to storage
    */
-  uploadFile(
-    userId: string,
-    path: string,
-    file: File | Blob,
-    options?: UploadOptions
-  ): Promise<UploadResult>
+  uploadFile(userId: string, path: string, file: File | Blob, options?: any): Promise<any>
 
   /**
    * 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>
+  uploadImage(userId: string, file: File, filename?: string): Promise<any>
 
   /**
    * Upload profile picture
    */
-  uploadProfilePicture(userId: string, file: File): Promise<UploadResult>
+  uploadProfilePicture(userId: string, file: File): Promise<any>
 
   /**
    * Get download URL for a file
@@ -62,82 +34,13 @@ export interface IFileRepository {
    */
   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[]>
-
-  /**
-   * Get file metadata
-   */
-  getFileMetadata(path: string): Promise<FileMetadata>
-
-  /**
-   * Query files with filters
-   */
-  queryFiles(userId: string, filters?: FileFilters): Promise<FileQueryResult>
-
-  /**
-   * Get storage statistics
-   */
-  getStorageStats(userId: string): Promise<StorageStats>
-
   /**
    * 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
+  validateFile(file: File, options?: any): boolean
 }

package/src/domain/interfaces/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Domain Interfaces
+ */
+
+export * from './auth.repository.interface'
+export * from './user.repository.interface'
+export * from './file.repository.interface'