@umituz/web-firebase 1.0.5 → 2.1.0

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

@@ -0,0 +1,75 @@
+/**
+ * User Repository Interface
+ * @description Defines contract for user data operations
+ */
+
+import type { User } from '../entities/user.entity'
+import type { QueryConstraint } from 'firebase/firestore'
+
+/**
+ * User Repository Interface
+ * Defines operations for user data management
+ */
+export interface IUserRepository {
+  /**
+   * 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/domain/value-objects/email.vo.ts

@@ -0,0 +1,105 @@
+/**
+ * Email Value Object
+ * @description Immutable email address value object with validation
+ */
+
+export class Email {
+  private readonly value: string
+  private readonly validated: boolean
+
+  constructor(email: string) {
+    this.value = email.trim().toLowerCase()
+    this.validated = this.isValid()
+    if (!this.validated) {
+      throw new Error(`Invalid email address: ${email}`)
+    }
+  }
+
+  /**
+   * Validate email format
+   */
+  private isValid(): boolean {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+    return emailRegex.test(this.value)
+  }
+
+  /**
+   * Get email value
+   */
+  getValue(): string {
+    return this.value
+  }
+
+  /**
+   * Get local part (before @)
+   */
+  getLocalPart(): string {
+    return this.value.split('@')[0]
+  }
+
+  /**
+   * Get domain part (after @)
+   */
+  getDomain(): string {
+    return this.value.split('@')[1] || ''
+  }
+
+  /**
+   * Check if email is from a specific domain
+   */
+  isFromDomain(domain: string): boolean {
+    return this.getDomain() === domain.toLowerCase()
+  }
+
+  /**
+   * Check if email is from a corporate domain (not gmail, yahoo, etc.)
+   */
+  isCorporate(): boolean {
+    const freeDomains = [
+      'gmail.com',
+      'yahoo.com',
+      'hotmail.com',
+      'outlook.com',
+      'aol.com',
+      'icloud.com',
+      'protonmail.com',
+    ]
+    return !freeDomains.includes(this.getDomain())
+  }
+
+  /**
+   * Mask email for display (e.g., u***@gmail.com)
+   */
+  mask(): string {
+    const [local, domain] = this.value.split('@')
+    if (local.length <= 2) {
+      return `${local[0]}***@${domain}`
+    }
+    return `${local[0]}${'*'.repeat(local.length - 2)}${local[local.length - 1]}@${domain}`
+  }
+
+  /**
+   * Convert to string
+   */
+  toString(): string {
+    return this.value
+  }
+
+  /**
+   * Check equality with another email
+   */
+  equals(other: Email): boolean {
+    return this.value === other.value
+  }
+
+  /**
+   * Create Email from string (returns null if invalid)
+   */
+  static create(email: string): Email | null {
+    try {
+      return new Email(email)
+    } catch {
+      return null
+    }
+  }
+}

package/src/domain/value-objects/file-path.vo.ts

@@ -0,0 +1,184 @@
+/**
+ * FilePath Value Object
+ * @description Immutable file path value object with validation for Firebase Storage paths
+ */
+
+import { createRepositoryError, RepositoryErrorCode } from '../errors/repository.errors'
+
+export class FilePath {
+  private readonly value: string
+  private readonly parts: string[]
+
+  constructor(path: string) {
+    this.value = path.trim()
+    this.parts = this.value.split('/').filter(p => p.length > 0)
+    this.validate()
+  }
+
+  /**
+   * Validate file path
+   */
+  private validate(): void {
+    if (!this.value) {
+      throw createRepositoryError(RepositoryErrorCode.INVALID_DATA, 'File path cannot be empty')
+    }
+
+    // Path should not start or end with /
+    if (this.value.startsWith('/') || this.value.endsWith('/')) {
+      throw createRepositoryError(
+        RepositoryErrorCode.INVALID_DATA,
+        'File path should not start or end with /'
+      )
+    }
+
+    // Path should not contain //
+    if (this.value.includes('//')) {
+      throw createRepositoryError(RepositoryErrorCode.INVALID_DATA, 'File path should not contain //')
+    }
+
+    // Path segments should not be empty
+    if (this.parts.length === 0) {
+      throw createRepositoryError(RepositoryErrorCode.INVALID_DATA, 'File path must have at least one segment')
+    }
+
+    // Validate each segment
+    for (const part of this.parts) {
+      // Segments should not contain invalid characters
+      if (/[<>:"|?*]/.test(part)) {
+        throw createRepositoryError(
+          RepositoryErrorCode.INVALID_DATA,
+          `Invalid characters in path segment: ${part}`
+        )
+      }
+
+      // Segments should not be . or ..
+      if (part === '.' || part === '..') {
+        throw createRepositoryError(
+          RepositoryErrorCode.INVALID_DATA,
+          `Invalid path segment: ${part}`
+        )
+      }
+    }
+  }
+
+  /**
+   * Get file path value
+   */
+  getValue(): string {
+    return this.value
+  }
+
+  /**
+   * Get path parts
+   */
+  getParts(): string[] {
+    return [...this.parts]
+  }
+
+  /**
+   * Get filename (last part of path)
+   */
+  getFileName(): string {
+    return this.parts[this.parts.length - 1] || ''
+  }
+
+  /**
+   * Get directory path (all parts except last)
+   */
+  getDirectory(): string {
+    return this.parts.slice(0, -1).join('/')
+  }
+
+  /**
+   * Get file extension
+   */
+  getExtension(): string {
+    const fileName = this.getFileName()
+    const lastDot = fileName.lastIndexOf('.')
+    return lastDot > 0 ? fileName.substring(lastDot + 1) : ''
+  }
+
+  /**
+   * Get file name without extension
+   */
+  getFileNameWithoutExtension(): string {
+    const fileName = this.getFileName()
+    const lastDot = fileName.lastIndexOf('.')
+    return lastDot > 0 ? fileName.substring(0, lastDot) : fileName
+  }
+
+  /**
+   * Check if path is in a specific directory
+   */
+  isInDirectory(directory: string): boolean {
+    return this.value.startsWith(directory + '/')
+  }
+
+  /**
+   * Check if file has a specific extension
+   */
+  hasExtension(extension: string): boolean {
+    return this.getExtension().toLowerCase() === extension.toLowerCase()
+  }
+
+  /**
+   * Create a new path by appending segments
+   */
+  append(...segments: string[]): FilePath {
+    return new FilePath([...this.parts, ...segments].join('/'))
+  }
+
+  /**
+   * Create a new path in a parent directory
+   */
+  withParent(parent: string): FilePath {
+    return new FilePath([parent, ...this.parts].join('/'))
+  }
+
+  /**
+   * Create a new path with a different filename
+   */
+  withFileName(fileName: string): FilePath {
+    const dir = this.getDirectory()
+    return dir ? new FilePath(`${dir}/${fileName}`) : new FilePath(fileName)
+  }
+
+  /**
+   * Convert to string
+   */
+  toString(): string {
+    return this.value
+  }
+
+  /**
+   * Check equality with another file path
+   */
+  equals(other: FilePath): boolean {
+    return this.value === other.value
+  }
+
+  /**
+   * Create user path (users/{userId}/...)
+   */
+  static userPath(userId: string, ...segments: string[]): FilePath {
+    return new FilePath(['users', userId, ...segments].join('/'))
+  }
+
+  /**
+   * Create public path (public/...)
+   */
+  static publicPath(...segments: string[]): FilePath {
+    return new FilePath(['public', ...segments].join('/'))
+  }
+
+  /**
+   * Create FilePath from string (returns null if invalid)
+   */
+  static create(path: string): FilePath | null {
+    try {
+      return new FilePath(path)
+    } catch {
+      return null
+    }
+  }
+}

package/src/domain/value-objects/user-id.vo.ts

@@ -0,0 +1,87 @@
+/**
+ * UserId Value Object
+ * @description Immutable user ID value object with validation
+ */
+
+import { createRepositoryError, RepositoryErrorCode } from '../errors/repository.errors'
+
+export class UserId {
+  private readonly value: string
+
+  constructor(id: string) {
+    this.value = id
+    this.validate()
+  }
+
+  /**
+   * Validate user ID
+   */
+  private validate(): void {
+    if (!this.value) {
+      throw createRepositoryError(RepositoryErrorCode.INVALID_DATA, 'User ID cannot be empty')
+    }
+
+    // Firebase Auth UIDs are typically at least 20 characters
+    if (this.value.length < 20) {
+      throw createRepositoryError(
+        RepositoryErrorCode.INVALID_DATA,
+        'User ID is too short (must be at least 20 characters)'
+      )
+    }
+
+    // Firebase UIDs contain only alphanumeric characters and certain special characters
+    const validPattern = /^[a-zA-Z0-9_-]+$/
+    if (!validPattern.test(this.value)) {
+      throw createRepositoryError(
+        RepositoryErrorCode.INVALID_DATA,
+        'User ID contains invalid characters'
+      )
+    }
+  }
+
+  /**
+   * Get user ID value
+   */
+  getValue(): string {
+    return this.value
+  }
+
+  /**
+   * Check if this is a temporary ID (not yet persisted)
+   */
+  isTemporary(): boolean {
+    return this.value.startsWith('temp_')
+  }
+
+  /**
+   * Convert to string
+   */
+  toString(): string {
+    return this.value
+  }
+
+  /**
+   * Check equality with another user ID
+   */
+  equals(other: UserId): boolean {
+    return this.value === other.value
+  }
+
+  /**
+   * Generate a temporary user ID
+   */
+  static generateTemp(): UserId {
+    return new UserId(`temp_${Date.now()}_${Math.random().toString(36).substring(7)}`)
+  }
+
+  /**
+   * Create UserId from string (returns null if invalid)
+   */
+  static create(id: string): UserId | null {
+    try {
+      return new UserId(id)
+    } catch {
+      return null
+    }
+  }
+}

package/src/index.ts

@@ -1,8 +1,23 @@
 /**
  * @umituz/web-firebase
- * Universal Firebase utilities for web
+ * Comprehensive Firebase integration with DDD 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
  */
 
-export * from './domain';
-export * from './infrastructure';
-export * from './presentation';
+// Domain entities, value objects, interfaces, errors
+export * from './domain'
+
+// Application use cases and DTOs
+export * from './application'
+
+// Infrastructure Firebase adapters
+export * from './infrastructure'
+
+// Presentation hooks and providers
+export * from './presentation'

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

@@ -0,0 +1,220 @@
+/**
+ * Auth Adapter
+ * @description Firebase Auth implementation of IAuthRepository
+ * Migrated from: /Users/umituz/Desktop/github/umituz/apps/web/app-growth-factory/src/domains/firebase/services/auth.ts
+ */
+
+import {
+  signInWithEmailAndPassword,
+  signInWithPopup,
+  createUserWithEmailAndPassword,
+  signOut as firebaseSignOut,
+  sendPasswordResetEmail,
+  sendEmailVerification,
+  updateProfile as updateAuthProfile,
+  updateEmail as updateAuthEmail,
+  updatePassword as updateAuthPassword,
+  reauthenticateWithCredential,
+  EmailAuthProvider,
+  User as FirebaseUser,
+  UserCredential,
+} from 'firebase/auth'
+import { GoogleAuthProvider } from 'firebase/auth'
+import { getFirebaseAuth } from './client'
+import type { IAuthRepository } from '../../domain/interfaces/auth.repository.interface'
+import type { User } from '../../domain/entities/user.entity'
+import { createAuthError, AuthErrorCode } from '../../domain/errors/auth.errors'
+
+export class AuthAdapter implements IAuthRepository {
+  private get auth() {
+    return getFirebaseAuth()
+  }
+
+  // Authentication Methods
+
+  async signIn(email: string, password: string): Promise<UserCredential> {
+    try {
+      return await signInWithEmailAndPassword(this.auth, email, password)
+    } catch (error) {
+      throw this.handleAuthError(error)
+    }
+  }
+
+  async signUp(email: string, password: string, displayName: string): Promise<UserCredential> {
+    try {
+      const result = await createUserWithEmailAndPassword(this.auth, email, password)
+
+      // Update profile
+      await updateAuthProfile(result.user, { displayName })
+
+      // Send email verification
+      await sendEmailVerification(result.user)
+
+      return result
+    } catch (error) {
+      throw this.handleAuthError(error)
+    }
+  }
+
+  async signInWithGoogle(): Promise<UserCredential> {
+    try {
+      const provider = new GoogleAuthProvider()
+      provider.addScope('profile')
+      provider.addScope('email')
+
+      return await signInWithPopup(this.auth, provider)
+    } catch (error) {
+      throw this.handleAuthError(error)
+    }
+  }
+
+  async signOut(): Promise<void> {
+    try {
+      await firebaseSignOut(this.auth)
+    } catch (error) {
+      throw createAuthError(AuthErrorCode.SIGN_OUT_FAILED, 'Sign out failed', error)
+    }
+  }
+
+  async sendPasswordReset(email: string): Promise<void> {
+    try {
+      await sendPasswordResetEmail(this.auth, email)
+    } catch (error) {
+      throw this.handleAuthError(error)
+    }
+  }
+
+  async resendEmailVerification(): Promise<void> {
+    try {
+      const user = this.auth.currentUser
+      if (!user) {
+        throw createAuthError(AuthErrorCode.UNAUTHENTICATED, 'No user logged in')
+      }
+      await sendEmailVerification(user)
+    } catch (error) {
+      throw createAuthError(AuthErrorCode.EMAIL_VERIFICATION_FAILED, 'Failed to resend verification', error)
+    }
+  }
+
+  // Profile Management
+
+  async updateProfile(
+    updates: Partial<Pick<User['profile'], 'displayName' | 'photoURL'>>
+  ): Promise<void> {
+    try {
+      const user = this.auth.currentUser
+      if (!user) {
+        throw createAuthError(AuthErrorCode.UNAUTHENTICATED, 'No user logged in')
+      }
+
+      await updateAuthProfile(user, updates)
+    } catch (error) {
+      throw createAuthError(AuthErrorCode.PROFILE_UPDATE_FAILED, 'Profile update failed', error)
+    }
+  }
+
+  async updateEmail(newEmail: string, password: string): Promise<void> {
+    try {
+      const user = this.auth.currentUser
+      if (!user || !user.email) {
+        throw createAuthError(AuthErrorCode.UNAUTHENTICATED, 'No user logged in')
+      }
+
+      const credential = EmailAuthProvider.credential(user.email, password)
+      await reauthenticateWithCredential(user, credential)
+      await updateAuthEmail(user, newEmail)
+    } catch (error) {
+      throw createAuthError(AuthErrorCode.EMAIL_UPDATE_FAILED, 'Email update failed', error)
+    }
+  }
+
+  async updatePassword(currentPassword: string, newPassword: string): Promise<void> {
+    try {
+      const user = this.auth.currentUser
+      if (!user || !user.email) {
+        throw createAuthError(AuthErrorCode.UNAUTHENTICATED, 'No user logged in')
+      }
+
+      const credential = EmailAuthProvider.credential(user.email, currentPassword)
+      await reauthenticateWithCredential(user, credential)
+      await updateAuthPassword(user, newPassword)
+    } catch (error) {
+      throw createAuthError(AuthErrorCode.PASSWORD_UPDATE_FAILED, 'Password update failed', error)
+    }
+  }
+
+  async deleteAccount(password: string): Promise<void> {
+    try {
+      const user = this.auth.currentUser
+      if (!user || !user.email) {
+        throw createAuthError(AuthErrorCode.UNAUTHENTICATED, 'No user logged in')
+      }
+
+      const credential = EmailAuthProvider.credential(user.email, password)
+      await reauthenticateWithCredential(user, credential)
+      await user.delete()
+    } catch (error) {
+      throw createAuthError(AuthErrorCode.ACCOUNT_DELETE_FAILED, 'Account deletion failed', error)
+    }
+  }
+
+  // State Management
+
+  getCurrentUser(): FirebaseUser | null {
+    return this.auth.currentUser
+  }
+
+  onAuthStateChanged(callback: (user: FirebaseUser | null) => void) {
+    return this.auth.onAuthStateChanged(callback)
+  }
+
+  // Note: User document operations should be handled by UserAdapter
+  // These methods are part of IAuthRepository interface but should be implemented separately
+  async createUserDocument(
+    _userId: string,
+    _data: Partial<Omit<User, 'profile'>> & { email: string; displayName: string }
+  ): Promise<void> {
+    throw new Error('createUserDocument should be handled by UserAdapter')
+  }
+
+  async updateLastLogin(_userId: string): Promise<void> {
+    throw new Error('updateLastLogin should be handled by UserAdapter')
+  }
+
+  /**
+   * Handle Firebase Auth errors
+   */
+  private handleAuthError(error: unknown): Error {
+    if (error instanceof Error && 'code' in error) {
+      const code = (error as { code: string }).code
+
+      switch (code) {
+        case 'auth/user-not-found':
+          return createAuthError(AuthErrorCode.USER_NOT_FOUND, 'User not found', error)
+        case 'auth/wrong-password':
+        case 'auth/invalid-credential':
+          return createAuthError(AuthErrorCode.INVALID_CREDENTIALS, 'Invalid credentials', error)
+        case 'auth/email-already-in-use':
+          return createAuthError(AuthErrorCode.USER_ALREADY_EXISTS, 'Email already in use', error)
+        case 'auth/weak-password':
+          return createAuthError(AuthErrorCode.WEAK_PASSWORD, 'Password is too weak', error)
+        case 'auth/invalid-email':
+          return createAuthError(AuthErrorCode.INVALID_CREDENTIALS, 'Invalid email', error)
+        case 'auth/user-disabled':
+          return createAuthError(AuthErrorCode.USER_NOT_FOUND, 'Account disabled', error)
+        case 'auth/too-many-requests':
+          return createAuthError(AuthErrorCode.TOO_MANY_REQUESTS, 'Too many requests', error)
+        case 'auth/popup-closed-by-user':
+          return createAuthError(AuthErrorCode.OAUTH_CANCELLED, 'Sign in cancelled', error)
+        case 'auth/account-exists-with-different-credential':
+          return createAuthError(AuthErrorCode.OAUTH_ACCOUNT_EXISTS, 'Account exists with different provider', error)
+        case 'auth/requires-recent-login':
+          return createAuthError(AuthErrorCode.REAUTHENTICATION_REQUIRED, 'Please reauthenticate', error)
+        default:
+          return createAuthError(AuthErrorCode.UNKNOWN, `Auth error: ${code}`, error)
+      }
+    }
+
+    return createAuthError(AuthErrorCode.UNKNOWN, 'Unknown auth error', error)
+  }
+}