@umituz/web-firebase 1.0.5 → 2.1.0

package/src/application/use-cases/auth/sign-in.use-case.ts

@@ -0,0 +1,77 @@
+/**
+ * Sign In Use Case
+ * @description Handles user sign in with email/password
+ */
+
+import type { UserCredential } from 'firebase/auth'
+import type { IAuthRepository } from '../../../domain/interfaces/auth.repository.interface'
+import type { SignInDTO } from '../../dto/auth.dto'
+import { createAuthError, AuthErrorCode } from '../../../domain/errors/auth.errors'
+
+export class SignInUseCase {
+  constructor(private readonly authRepository: IAuthRepository) {}
+
+  /**
+   * Execute sign in use case
+   */
+  async execute(dto: SignInDTO): Promise<UserCredential> {
+    try {
+      // Validate input
+      this.validateDTO(dto)
+
+      // Perform sign in
+      const result = await this.authRepository.signIn(dto.email, dto.password)
+
+      return result
+    } catch (error) {
+      throw this.handleError(error)
+    }
+  }
+
+  /**
+   * Validate DTO
+   */
+  private validateDTO(dto: SignInDTO): void {
+    if (!dto.email) {
+      throw createAuthError(AuthErrorCode.INVALID_CREDENTIALS, 'Email is required')
+    }
+
+    if (!dto.password) {
+      throw createAuthError(AuthErrorCode.INVALID_CREDENTIALS, 'Password is required')
+    }
+
+    // Basic email validation
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+    if (!emailRegex.test(dto.email)) {
+      throw createAuthError(AuthErrorCode.INVALID_CREDENTIALS, 'Invalid email format')
+    }
+  }
+
+  /**
+   * Handle errors
+   */
+  private handleError(error: unknown): Error {
+    if (error instanceof Error) {
+      // Firebase auth errors
+      const message = error.message.toLowerCase()
+
+      if (message.includes('user-not-found') || message.includes('invalid-email')) {
+        return createAuthError(AuthErrorCode.USER_NOT_FOUND, 'User not found', error)
+      }
+
+      if (message.includes('wrong-password') || message.includes('invalid-credential')) {
+        return createAuthError(AuthErrorCode.INVALID_CREDENTIALS, 'Invalid credentials', error)
+      }
+
+      if (message.includes('too-many-requests')) {
+        return createAuthError(AuthErrorCode.TOO_MANY_REQUESTS, 'Too many attempts', error)
+      }
+
+      if (message.includes('user-disabled')) {
+        return createAuthError(AuthErrorCode.USER_NOT_FOUND, 'Account disabled', error)
+      }
+    }
+
+    return createAuthError(AuthErrorCode.SIGN_IN_FAILED, 'Sign in failed', error)
+  }
+}

package/src/application/use-cases/auth/sign-out.use-case.ts

@@ -0,0 +1,22 @@
+/**
+ * Sign Out Use Case
+ * @description Handles user sign out
+ */
+
+import type { IAuthRepository } from '../../../domain/interfaces/auth.repository.interface'
+import { createAuthError, AuthErrorCode } from '../../../domain/errors/auth.errors'
+
+export class SignOutUseCase {
+  constructor(private readonly authRepository: IAuthRepository) {}
+
+  /**
+   * Execute sign out use case
+   */
+  async execute(): Promise<void> {
+    try {
+      await this.authRepository.signOut()
+    } catch (error) {
+      throw createAuthError(AuthErrorCode.SIGN_OUT_FAILED, 'Sign out failed', error)
+    }
+  }
+}

package/src/application/use-cases/auth/sign-up.use-case.ts

@@ -0,0 +1,99 @@
+/**
+ * Sign Up Use Case
+ * @description Handles user registration with email/password
+ */
+
+import type { IAuthRepository } from '../../../domain/interfaces/auth.repository.interface'
+import type { IUserRepository } from '../../../domain/interfaces/user.repository.interface'
+import type { SignUpDTO, SignUpResult } from '../../dto/auth.dto'
+import { createAuthError, AuthErrorCode } from '../../../domain/errors/auth.errors'
+
+export class SignUpUseCase {
+  constructor(
+    private readonly authRepository: IAuthRepository,
+    private readonly userRepository: IUserRepository
+  ) {}
+
+  /**
+   * Execute sign up use case
+   */
+  async execute(dto: SignUpDTO): Promise<SignUpResult> {
+    try {
+      // Validate input
+      this.validateDTO(dto)
+
+      // Check if user already exists
+      const existingUser = await this.userRepository.getUserByEmail(dto.email)
+      if (existingUser) {
+        throw createAuthError(AuthErrorCode.USER_ALREADY_EXISTS, 'User already exists')
+      }
+
+      // Perform sign up
+      const result = await this.authRepository.signUp(dto.email, dto.password, dto.displayName)
+
+      // Return enhanced result
+      return {
+        ...result,
+        userId: result.user.uid,
+        emailVerified: result.user.emailVerified,
+      }
+    } catch (error) {
+      throw this.handleError(error)
+    }
+  }
+
+  /**
+   * Validate DTO
+   */
+  private validateDTO(dto: SignUpDTO): void {
+    if (!dto.email) {
+      throw createAuthError(AuthErrorCode.SIGN_UP_FAILED, 'Email is required')
+    }
+
+    if (!dto.password) {
+      throw createAuthError(AuthErrorCode.SIGN_UP_FAILED, 'Password is required')
+    }
+
+    if (!dto.displayName || dto.displayName.trim().length === 0) {
+      throw createAuthError(AuthErrorCode.SIGN_UP_FAILED, 'Display name is required')
+    }
+
+    // Email validation
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+    if (!emailRegex.test(dto.email)) {
+      throw createAuthError(AuthErrorCode.SIGN_UP_FAILED, 'Invalid email format')
+    }
+
+    // Password strength validation
+    if (dto.password.length < 6) {
+      throw createAuthError(AuthErrorCode.WEAK_PASSWORD, 'Password must be at least 6 characters')
+    }
+  }
+
+  /**
+   * Handle errors
+   */
+  private handleError(error: unknown): Error {
+    if (error instanceof Error && 'code' in error) {
+      const code = (error as { code: string }).code
+
+      if (code === 'auth/email-already-in-use') {
+        return createAuthError(AuthErrorCode.USER_ALREADY_EXISTS, 'Email already in use', error)
+      }
+
+      if (code === 'auth/invalid-email') {
+        return createAuthError(AuthErrorCode.SIGN_UP_FAILED, 'Invalid email', error)
+      }
+
+      if (code === 'auth/weak-password') {
+        return createAuthError(AuthErrorCode.WEAK_PASSWORD, 'Password is too weak', error)
+      }
+
+      if (code === 'auth/operation-not-allowed') {
+        return createAuthError(AuthErrorCode.SIGN_UP_FAILED, 'Email/password accounts not enabled', error)
+      }
+    }
+
+    return createAuthError(AuthErrorCode.SIGN_UP_FAILED, 'Sign up failed', error)
+  }
+}

package/src/application/use-cases/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Application Use Cases
+ * @description Use cases for auth and user operations
+ */
+
+export * from './auth/sign-in.use-case'
+export * from './auth/sign-up.use-case'
+export * from './auth/sign-in-with-google.use-case'
+export * from './auth/reset-password.use-case'
+export * from './auth/sign-out.use-case'
+export * from './user/update-profile.use-case'
+export * from './user/delete-account.use-case'

package/src/application/use-cases/user/delete-account.use-case.ts

@@ -0,0 +1,77 @@
+/**
+ * Delete Account Use Case
+ * @description Handles user account deletion
+ */
+
+import type { IAuthRepository } from '../../../domain/interfaces/auth.repository.interface'
+import type { DeleteAccountDTO } from '../../dto/auth.dto'
+import { createAuthError, AuthErrorCode } from '../../../domain/errors/auth.errors'
+
+export class DeleteAccountUseCase {
+  constructor(private readonly authRepository: IAuthRepository) {}
+
+  /**
+   * Execute account deletion use case
+   */
+  async execute(dto: DeleteAccountDTO): Promise<void> {
+    try {
+      // Validate input
+      this.validateDTO(dto)
+
+      // Check if user is authenticated
+      const currentUser = this.authRepository.getCurrentUser()
+      if (!currentUser) {
+        throw createAuthError(AuthErrorCode.UNAUTHENTICATED, 'No user logged in')
+      }
+
+      if (!currentUser.email) {
+        throw createAuthError(AuthErrorCode.ACCOUNT_DELETE_FAILED, 'User email not available')
+      }
+
+      // Delete account (includes password verification)
+      await this.authRepository.deleteAccount(dto.password)
+    } catch (error) {
+      throw this.handleError(error)
+    }
+  }
+
+  /**
+   * Validate DTO
+   */
+  private validateDTO(dto: DeleteAccountDTO): void {
+    if (!dto.password) {
+      throw createAuthError(AuthErrorCode.ACCOUNT_DELETE_FAILED, 'Password is required')
+    }
+
+    if (dto.password.length < 1) {
+      throw createAuthError(AuthErrorCode.ACCOUNT_DELETE_FAILED, 'Password cannot be empty')
+    }
+  }
+
+  /**
+   * Handle errors
+   */
+  private handleError(error: unknown): Error {
+    if (error instanceof Error && 'code' in error) {
+      const code = (error as { code: string }).code
+
+      if (code === 'auth/requires-recent-login') {
+        return createAuthError(AuthErrorCode.REAUTHENTICATION_REQUIRED, 'Please reauthenticate first', error)
+      }
+
+      if (code === 'auth/wrong-password') {
+        return createAuthError(AuthErrorCode.REAUTHENTICATION_FAILED, 'Invalid password', error)
+      }
+
+      if (code === 'auth/too-many-requests') {
+        return createAuthError(AuthErrorCode.TOO_MANY_REQUESTS, 'Too many requests', error)
+      }
+
+      if (code === 'auth/user-not-found') {
+        return createAuthError(AuthErrorCode.ACCOUNT_DELETE_FAILED, 'User not found', error)
+      }
+    }
+
+    return createAuthError(AuthErrorCode.ACCOUNT_DELETE_FAILED, 'Account deletion failed', error)
+  }
+}

package/src/application/use-cases/user/update-profile.use-case.ts

@@ -0,0 +1,98 @@
+/**
+ * Update Profile Use Case
+ * @description Handles user profile updates
+ */
+
+import type { IAuthRepository } from '../../../domain/interfaces/auth.repository.interface'
+import type { UpdateProfileDTO } from '../../dto/auth.dto'
+import { createAuthError, AuthErrorCode } from '../../../domain/errors/auth.errors'
+
+export class UpdateProfileUseCase {
+  constructor(private readonly authRepository: IAuthRepository) {}
+
+  /**
+   * Execute profile update use case
+   */
+  async execute(dto: UpdateProfileDTO): Promise<void> {
+    try {
+      // Validate input
+      this.validateDTO(dto)
+
+      // Check if user is authenticated
+      const currentUser = this.authRepository.getCurrentUser()
+      if (!currentUser) {
+        throw createAuthError(AuthErrorCode.UNAUTHENTICATED, 'No user logged in')
+      }
+
+      // Update profile
+      await this.authRepository.updateProfile(dto)
+    } catch (error) {
+      throw this.handleError(error)
+    }
+  }
+
+  /**
+   * Validate DTO
+   */
+  private validateDTO(dto: UpdateProfileDTO): void {
+    if (!dto.displayName && !dto.photoURL) {
+      throw createAuthError(AuthErrorCode.PROFILE_UPDATE_FAILED, 'At least one field must be provided')
+    }
+
+    if (dto.displayName !== undefined) {
+      if (typeof dto.displayName !== 'string') {
+        throw createAuthError(AuthErrorCode.PROFILE_UPDATE_FAILED, 'Display name must be a string')
+      }
+
+      if (dto.displayName.trim().length === 0) {
+        throw createAuthError(AuthErrorCode.PROFILE_UPDATE_FAILED, 'Display name cannot be empty')
+      }
+
+      if (dto.displayName.length > 100) {
+        throw createAuthError(AuthErrorCode.PROFILE_UPDATE_FAILED, 'Display name too long (max 100 characters)')
+      }
+    }
+
+    if (dto.photoURL !== undefined && dto.photoURL !== null) {
+      if (typeof dto.photoURL !== 'string') {
+        throw createAuthError(AuthErrorCode.PROFILE_UPDATE_FAILED, 'Photo URL must be a string')
+      }
+
+      // Basic URL validation
+      if (dto.photoURL && !this.isValidURL(dto.photoURL)) {
+        throw createAuthError(AuthErrorCode.PROFILE_UPDATE_FAILED, 'Invalid photo URL')
+      }
+    }
+  }
+
+  /**
+   * Validate URL format
+   */
+  private isValidURL(url: string): boolean {
+    try {
+      new URL(url)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Handle errors
+   */
+  private handleError(error: unknown): Error {
+    if (error instanceof Error && 'code' in error) {
+      const code = (error as { code: string }).code
+
+      if (code === 'auth/requires-recent-login') {
+        return createAuthError(AuthErrorCode.REAUTHENTICATION_REQUIRED, 'Please reauthenticate first', error)
+      }
+
+      if (code === 'auth/invalid-photo-url') {
+        return createAuthError(AuthErrorCode.PROFILE_UPDATE_FAILED, 'Invalid photo URL', error)
+      }
+    }
+
+    return createAuthError(AuthErrorCode.PROFILE_UPDATE_FAILED, 'Profile update failed', error)
+  }
+}

package/src/domain/entities/file.entity.ts

@@ -0,0 +1,151 @@
+/**
+ * File 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>
+}
+
+/**
+ * File Validation Options
+ */
+export interface FileValidationOptions {
+  maxSizeBytes?: number
+  maxSizeMB?: number
+  allowedTypes?: string[]
+  allowedExtensions?: string[]
+}
+
+/**
+ * Validation Result
+ */
+export interface ValidationResult {
+  valid: boolean
+  error?: string
+  errorCode?: FileErrorCode
+}
+
+/**
+ * File Error Codes
+ */
+export enum FileErrorCode {
+  FILE_TOO_LARGE = 'FILE_TOO_LARGE',
+  INVALID_TYPE = 'INVALID_TYPE',
+  INVALID_EXTENSION = 'INVALID_EXTENSION',
+  UPLOAD_FAILED = 'UPLOAD_FAILED',
+  DOWNLOAD_FAILED = 'DOWNLOAD_FAILED',
+  DELETE_FAILED = 'DELETE_FAILED',
+  FILE_NOT_FOUND = 'FILE_NOT_FOUND',
+  NETWORK_ERROR = 'NETWORK_ERROR',
+  CANCELLED = 'CANCELLED',
+}
+
+/**
+ * File Filters
+ */
+export interface FileFilters {
+  type?: FileType
+  category?: FileCategory
+  startDate?: number
+  endDate?: number
+  minSize?: number
+  maxSize?: number
+  tags?: string[]
+}
+
+/**
+ * File Query Result
+ */
+export interface FileQueryResult {
+  files: FileMetadata[]
+  totalCount: number
+  hasMore: boolean
+  lastDocId?: string
+}
+
+/**
+ * Storage Statistics
+ */
+export interface StorageStats {
+  totalFiles: number
+  totalSize: number
+  filesByType: Record<FileType, number>
+  filesByCategory: Record<FileCategory, number>
+  lastUploadAt?: number
+}

package/src/domain/entities/timestamp.entity.ts

@@ -0,0 +1,116 @@
+/**
+ * Timestamp Value Objects
+ * @description Value objects for handling timestamps in Firestore
+ */
+
+import type { Timestamp as FirestoreTimestamp } from 'firebase/firestore'
+
+/**
+ * Firebase Timestamp wrapper
+ * Provides type safety and utility methods for timestamp handling
+ */
+export class Timestamp {
+  constructor(
+    public readonly seconds: number,
+    public readonly nanoseconds: number
+  ) {}
+
+  /**
+   * Create Timestamp from JavaScript Date
+   */
+  static fromDate(date: Date): Timestamp {
+    const milliseconds = date.getTime()
+    const seconds = Math.floor(milliseconds / 1000)
+    const nanoseconds = (milliseconds % 1000) * 1_000_000
+    return new Timestamp(seconds, nanoseconds)
+  }
+
+  /**
+   * Create Timestamp from milliseconds
+   */
+  static fromMillis(milliseconds: number): Timestamp {
+    const seconds = Math.floor(milliseconds / 1000)
+    const nanoseconds = (milliseconds % 1000) * 1_000_000
+    return new Timestamp(seconds, nanoseconds)
+  }
+
+  /**
+   * Create Timestamp from Firestore Timestamp
+   */
+  static fromFirestoreTimestamp(timestamp: FirestoreTimestamp): Timestamp {
+    return new Timestamp(timestamp.seconds, timestamp.nanoseconds)
+  }
+
+  /**
+   * Get current timestamp
+   */
+  static now(): Timestamp {
+    return Timestamp.fromDate(new Date())
+  }
+
+  /**
+   * Convert to JavaScript Date
+   */
+  toDate(): Date {
+    return new Date(this.seconds * 1000 + this.nanoseconds / 1_000_000)
+  }
+
+  /**
+   * Convert to milliseconds
+   */
+  toMillis(): number {
+    return this.seconds * 1000 + this.nanoseconds / 1_000_000
+  }
+
+  /**
+   * Convert to Firestore Timestamp
+   */
+  toFirestoreTimestamp(): FirestoreTimestamp {
+    return {
+      seconds: this.seconds,
+      nanoseconds: this.nanoseconds,
+    } as FirestoreTimestamp
+  }
+
+  /**
+   * Convert to ISO string
+   */
+  toISOString(): string {
+    return this.toDate().toISOString()
+  }
+
+  /**
+   * Check if timestamp is in the past
+   */
+  isPast(): boolean {
+    return this.toMillis() < Date.now()
+  }
+
+  /**
+   * Check if timestamp is in the future
+   */
+  isFuture(): boolean {
+    return this.toMillis() > Date.now()
+  }
+
+  /**
+   * Get difference in milliseconds with another timestamp
+   */
+  diff(other: Timestamp): number {
+    return this.toMillis() - other.toMillis()
+  }
+}
+
+/**
+ * Server timestamp sentinel for Firestore
+ */
+export const serverTimestamp = {
+  __type__: 'serverTimestamp',
+} as const
+
+export type ServerTimestamp = typeof serverTimestamp
+
+/**
+ * Timestamp field that can be a Timestamp, server timestamp, or ISO string
+ */
+export type TimestampField = Timestamp | ServerTimestamp | string