@umituz/web-firebase 1.0.4 → 2.0.1

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

@@ -0,0 +1,193 @@
+/**
+ * User Domain Entities
+ * @description Core user-related entities following DDD principles
+ * Migrated from: /Users/umituz/Desktop/github/umituz/apps/web/app-growth-factory/src/domains/firebase/types/index.ts
+ */
+
+/**
+ * User Profile Value Object
+ * Immutable user profile data
+ */
+export interface UserProfile {
+  readonly id: string
+  readonly email: string
+  readonly displayName: string
+  readonly photoURL?: string
+  readonly phoneNumber?: string
+  readonly createdAt: number
+  readonly updatedAt: number
+  readonly lastLoginAt: number
+  readonly emailVerified: boolean
+}
+
+/**
+ * User Notifications Settings
+ */
+export interface UserNotifications {
+  email: boolean
+  push: boolean
+  marketing: boolean
+  security: boolean
+  weeklyDigest: boolean
+}
+
+/**
+ * User Privacy Settings
+ */
+export interface UserPrivacy {
+  profileVisibility: 'public' | 'private'
+  showEmail: boolean
+  showPhone: boolean
+  dataSharing: boolean
+}
+
+/**
+ * User Settings Value Object
+ */
+export interface UserSettings {
+  theme: 'light' | 'dark' | 'system'
+  language: string
+  timezone: string
+  currency: string
+  notifications: UserNotifications
+  privacy: UserPrivacy
+}
+
+/**
+ * User Subscription Value Object
+ */
+export interface UserSubscription {
+  plan: 'free' | 'standard' | 'professional' | 'business'
+  status: 'active' | 'inactive' | 'canceled' | 'past_due'
+  polarCustomerId?: string
+  polarSubscriptionId?: string
+  currentPeriodStart?: number
+  currentPeriodEnd?: number
+  cancelAtPeriodEnd: boolean
+  readonly createdAt: number
+  readonly updatedAt: number
+}
+
+/**
+ * Account Metrics Value Object
+ */
+export interface AccountMetrics {
+  followers: number
+  following: number
+  posts: number
+  engagement: number
+  lastSyncedAt: number
+}
+
+/**
+ * User Connected Account Entity
+ */
+export interface UserConnectedAccount {
+  platform:
+    | 'twitter'
+    | 'facebook'
+    | 'instagram'
+    | 'linkedin'
+    | 'tiktok'
+    | 'youtube'
+    | 'pinterest'
+    | 'reddit'
+    | 'threads'
+    | 'discord'
+    | 'telegram'
+    | 'mastodon'
+    | 'medium'
+  connected: boolean
+  readonly connectedAt: number
+  username?: string
+  profileId?: string
+  accessToken?: string
+  refreshToken?: string
+  tokenExpiresAt?: number
+  metrics?: AccountMetrics
+}
+
+/**
+ * User Content Entity
+ */
+export interface UserContent {
+  readonly id: string
+  type: 'post' | 'article' | 'video' | 'image' | 'story' | 'reel'
+  title: string
+  content: string
+  platforms: string[]
+  status: 'draft' | 'scheduled' | 'published' | 'failed'
+  scheduledFor?: number
+  publishedAt?: number
+  readonly createdAt: number
+  readonly updatedAt: number
+  mediaUrls?: string[]
+  metadata?: Record<string, unknown>
+}
+
+/**
+ * Platform Breakdown for Analytics
+ */
+export interface PlatformBreakdown {
+  [platform: string]: {
+    posts: number
+    engagement: number
+    reach: number
+  }
+}
+
+/**
+ * User Analytics Value Object
+ */
+export interface UserAnalytics {
+  totalPosts: number
+  totalEngagement: number
+  totalReach: number
+  topPerformingPosts: string[] // content IDs
+  platformBreakdown: PlatformBreakdown
+  lastCalculatedAt: number
+}
+
+/**
+ * User Credits Value Object
+ */
+export interface UserCredits {
+  standard: number
+  professional: number
+  total: number
+  resetAt: number
+  lastResetAt: number
+}
+
+/**
+ * User Aggregate Root
+ * Main user document containing all user-related data
+ * This is the aggregate root for the User domain
+ */
+export interface User {
+  readonly profile: UserProfile
+  settings: UserSettings
+  subscription: UserSubscription
+  connectedAccounts: UserConnectedAccount[]
+  content: UserContent[]
+  analytics: UserAnalytics
+  credits: UserCredits
+}
+
+/**
+ * Collection Constants
+ */
+export const USER_COLLECTIONS = {
+  USERS: 'users',
+  CONTENT: 'content',
+  ANALYTICS: 'analytics',
+  CONNECTED_ACCOUNTS: 'connectedAccounts',
+} as const
+
+export const USER_SUBCOLLECTIONS = {
+  CONTENT: 'content',
+  ANALYTICS: 'analytics',
+  SCHEDULED: 'scheduled',
+  PUBLISHED: 'published',
+  DRAFTS: 'drafts',
+} as const

package/src/domain/errors/auth.errors.ts

@@ -0,0 +1,115 @@
+/**
+ * Domain Errors for Authentication
+ * @description Custom error types for authentication-related failures
+ */
+
+export class AuthError extends Error {
+  constructor(
+    message: string,
+    public code: AuthErrorCode,
+    public originalError?: unknown
+  ) {
+    super(message)
+    this.name = 'AuthError'
+  }
+}
+
+export enum AuthErrorCode {
+  // Auth Errors
+  USER_NOT_FOUND = 'USER_NOT_FOUND',
+  USER_ALREADY_EXISTS = 'USER_ALREADY_EXISTS',
+  INVALID_CREDENTIALS = 'INVALID_CREDENTIALS',
+  WEAK_PASSWORD = 'WEAK_PASSWORD',
+  EMAIL_NOT_VERIFIED = 'EMAIL_NOT_VERIFIED',
+
+  // Session Errors
+  SESSION_EXPIRED = 'SESSION_EXPIRED',
+  UNAUTHENTICATED = 'UNAUTHENTICATED',
+  TOO_MANY_REQUESTS = 'TOO_MANY_REQUESTS',
+
+  // Provider Errors
+  OAUTH_ERROR = 'OAUTH_ERROR',
+  OAUTH_CANCELLED = 'OAUTH_CANCELLED',
+  OAUTH_ACCOUNT_EXISTS = 'OAUTH_ACCOUNT_EXISTS',
+
+  // Operation Errors
+  SIGN_IN_FAILED = 'SIGN_IN_FAILED',
+  SIGN_UP_FAILED = 'SIGN_UP_FAILED',
+  SIGN_OUT_FAILED = 'SIGN_OUT_FAILED',
+  PASSWORD_RESET_FAILED = 'PASSWORD_RESET_FAILED',
+  EMAIL_VERIFICATION_FAILED = 'EMAIL_VERIFICATION_FAILED',
+
+  // Profile Errors
+  PROFILE_UPDATE_FAILED = 'PROFILE_UPDATE_FAILED',
+  EMAIL_UPDATE_FAILED = 'EMAIL_UPDATE_FAILED',
+  PASSWORD_UPDATE_FAILED = 'PASSWORD_UPDATE_FAILED',
+  ACCOUNT_DELETE_FAILED = 'ACCOUNT_DELETE_FAILED',
+
+  // Reauthentication Errors
+  REAUTHENTICATION_REQUIRED = 'REAUTHENTICATION_REQUIRED',
+  REAUTHENTICATION_FAILED = 'REAUTHENTICATION_FAILED',
+
+  // Unknown Error
+  UNKNOWN = 'UNKNOWN',
+}
+
+export function createAuthError(
+  code: AuthErrorCode,
+  message?: string,
+  originalError?: unknown
+): AuthError {
+  const defaultMessage = getAuthErrorMessage(code)
+  return new AuthError(message || defaultMessage, code, originalError)
+}
+
+function getAuthErrorMessage(code: AuthErrorCode): string {
+  switch (code) {
+    case AuthErrorCode.USER_NOT_FOUND:
+      return 'User not found'
+    case AuthErrorCode.USER_ALREADY_EXISTS:
+      return 'User already exists'
+    case AuthErrorCode.INVALID_CREDENTIALS:
+      return 'Invalid credentials'
+    case AuthErrorCode.WEAK_PASSWORD:
+      return 'Password is too weak'
+    case AuthErrorCode.EMAIL_NOT_VERIFIED:
+      return 'Email not verified'
+    case AuthErrorCode.SESSION_EXPIRED:
+      return 'Session expired'
+    case AuthErrorCode.UNAUTHENTICATED:
+      return 'User not authenticated'
+    case AuthErrorCode.TOO_MANY_REQUESTS:
+      return 'Too many requests'
+    case AuthErrorCode.OAUTH_ERROR:
+      return 'OAuth error occurred'
+    case AuthErrorCode.OAUTH_CANCELLED:
+      return 'OAuth cancelled by user'
+    case AuthErrorCode.OAUTH_ACCOUNT_EXISTS:
+      return 'Account already exists with this provider'
+    case AuthErrorCode.SIGN_IN_FAILED:
+      return 'Sign in failed'
+    case AuthErrorCode.SIGN_UP_FAILED:
+      return 'Sign up failed'
+    case AuthErrorCode.SIGN_OUT_FAILED:
+      return 'Sign out failed'
+    case AuthErrorCode.PASSWORD_RESET_FAILED:
+      return 'Password reset failed'
+    case AuthErrorCode.EMAIL_VERIFICATION_FAILED:
+      return 'Email verification failed'
+    case AuthErrorCode.PROFILE_UPDATE_FAILED:
+      return 'Profile update failed'
+    case AuthErrorCode.EMAIL_UPDATE_FAILED:
+      return 'Email update failed'
+    case AuthErrorCode.PASSWORD_UPDATE_FAILED:
+      return 'Password update failed'
+    case AuthErrorCode.ACCOUNT_DELETE_FAILED:
+      return 'Account deletion failed'
+    case AuthErrorCode.REAUTHENTICATION_REQUIRED:
+      return 'Reauthentication required'
+    case AuthErrorCode.REAUTHENTICATION_FAILED:
+      return 'Reauthentication failed'
+    case AuthErrorCode.UNKNOWN:
+    default:
+      return 'An unknown error occurred'
+  }
+}

package/src/domain/errors/repository.errors.ts

@@ -0,0 +1,121 @@
+/**
+ * Domain Errors for Repository Operations
+ * @description Custom error types for repository-related failures
+ */
+
+export class RepositoryError extends Error {
+  constructor(
+    message: string,
+    public code: RepositoryErrorCode,
+    public originalError?: unknown
+  ) {
+    super(message)
+    this.name = 'RepositoryError'
+  }
+}
+
+export enum RepositoryErrorCode {
+  // Document Errors
+  DOCUMENT_NOT_FOUND = 'DOCUMENT_NOT_FOUND',
+  DOCUMENT_ALREADY_EXISTS = 'DOCUMENT_ALREADY_EXISTS',
+  DOCUMENT_INVALID = 'DOCUMENT_INVALID',
+
+  // Collection Errors
+  COLLECTION_NOT_FOUND = 'COLLECTION_NOT_FOUND',
+  COLLECTION_INVALID = 'COLLECTION_INVALID',
+
+  // Query Errors
+  QUERY_INVALID = 'QUERY_INVALID',
+  QUERY_FAILED = 'QUERY_FAILED',
+
+  // Transaction Errors
+  TRANSACTION_FAILED = 'TRANSACTION_FAILED',
+  TRANSACTION_ABORTED = 'TRANSACTION_ABORTED',
+
+  // Network Errors
+  NETWORK_ERROR = 'NETWORK_ERROR',
+  TIMEOUT = 'TIMEOUT',
+  OFFLINE = 'OFFLINE',
+
+  // Permission Errors
+  PERMISSION_DENIED = 'PERMISSION_DENIED',
+  UNAUTHORIZED = 'UNAUTHORIZED',
+
+  // Validation Errors
+  VALIDATION_FAILED = 'VALIDATION_FAILED',
+  INVALID_DATA = 'INVALID_DATA',
+
+  // Concurrency Errors
+  CONFLICT = 'CONFLICT',
+  VERSION_MISMATCH = 'VERSION_MISMATCH',
+
+  // Storage Errors
+  STORAGE_ERROR = 'STORAGE_ERROR',
+  FILE_NOT_FOUND = 'FILE_NOT_FOUND',
+  FILE_TOO_LARGE = 'FILE_TOO_LARGE',
+  INVALID_FILE_TYPE = 'INVALID_FILE_TYPE',
+
+  // Unknown Error
+  UNKNOWN = 'UNKNOWN',
+}
+
+export function createRepositoryError(
+  code: RepositoryErrorCode,
+  message?: string,
+  originalError?: unknown
+): RepositoryError {
+  const defaultMessage = getRepositoryErrorMessage(code)
+  return new RepositoryError(message || defaultMessage, code, originalError)
+}
+
+function getRepositoryErrorMessage(code: RepositoryErrorCode): string {
+  switch (code) {
+    case RepositoryErrorCode.DOCUMENT_NOT_FOUND:
+      return 'Document not found'
+    case RepositoryErrorCode.DOCUMENT_ALREADY_EXISTS:
+      return 'Document already exists'
+    case RepositoryErrorCode.DOCUMENT_INVALID:
+      return 'Document is invalid'
+    case RepositoryErrorCode.COLLECTION_NOT_FOUND:
+      return 'Collection not found'
+    case RepositoryErrorCode.COLLECTION_INVALID:
+      return 'Collection is invalid'
+    case RepositoryErrorCode.QUERY_INVALID:
+      return 'Query is invalid'
+    case RepositoryErrorCode.QUERY_FAILED:
+      return 'Query failed'
+    case RepositoryErrorCode.TRANSACTION_FAILED:
+      return 'Transaction failed'
+    case RepositoryErrorCode.TRANSACTION_ABORTED:
+      return 'Transaction aborted'
+    case RepositoryErrorCode.NETWORK_ERROR:
+      return 'Network error'
+    case RepositoryErrorCode.TIMEOUT:
+      return 'Request timeout'
+    case RepositoryErrorCode.OFFLINE:
+      return 'Client is offline'
+    case RepositoryErrorCode.PERMISSION_DENIED:
+      return 'Permission denied'
+    case RepositoryErrorCode.UNAUTHORIZED:
+      return 'Unauthorized'
+    case RepositoryErrorCode.VALIDATION_FAILED:
+      return 'Validation failed'
+    case RepositoryErrorCode.INVALID_DATA:
+      return 'Invalid data'
+    case RepositoryErrorCode.CONFLICT:
+      return 'Conflict occurred'
+    case RepositoryErrorCode.VERSION_MISMATCH:
+      return 'Version mismatch'
+    case RepositoryErrorCode.STORAGE_ERROR:
+      return 'Storage error'
+    case RepositoryErrorCode.FILE_NOT_FOUND:
+      return 'File not found'
+    case RepositoryErrorCode.FILE_TOO_LARGE:
+      return 'File is too large'
+    case RepositoryErrorCode.INVALID_FILE_TYPE:
+      return 'Invalid file type'
+    case RepositoryErrorCode.UNKNOWN:
+    default:
+      return 'An unknown error occurred'
+  }
+}

package/src/domain/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Domain Layer
+ * Subpath: @umituz/web-firebase/domain
+ */
+
+/**
+ * Domain Layer Public API
+ * @description Exports all domain entities, value objects, interfaces, and errors
+ */
+
+// Entities
+export type { FirebaseUser, FirebaseTimestamp } from './entities/firebase.entity'
+export * from './entities/user.entity'
+export * from './entities/file.entity'
+export * from './entities/timestamp.entity'
+
+// Value Objects
+export * from './value-objects/email.vo'
+export * from './value-objects/user-id.vo'
+export * from './value-objects/file-path.vo'
+
+// Interfaces
+export * from './interfaces/repository.interface'
+export * from './interfaces/auth.repository.interface'
+export * from './interfaces/user.repository.interface'
+export * from './interfaces/file.repository.interface'
+
+// Errors
+export * from './errors/auth.errors'
+export * from './errors/repository.errors'

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

@@ -0,0 +1,83 @@
+/**
+ * Authentication Repository Interface
+ * @description Defines contract for authentication operations
+ */
+
+import type { User as FirebaseUser, UserCredential } from 'firebase/auth'
+import type { User } from '../entities/user.entity'
+
+/**
+ * Authentication Repository Interface
+ * Defines operations for user authentication and management
+ */
+export interface IAuthRepository {
+  /**
+   * Sign in with email and password
+   */
+  signIn(email: string, password: string): Promise<UserCredential>
+
+  /**
+   * Sign up with email, password, and display name
+   */
+  signUp(email: string, password: string, displayName: string): Promise<UserCredential>
+
+  /**
+   * Sign in with Google OAuth
+   */
+  signInWithGoogle(): Promise<UserCredential>
+
+  /**
+   * Sign out current user
+   */
+  signOut(): Promise<void>
+
+  /**
+   * Send password reset email
+   */
+  sendPasswordReset(email: string): Promise<void>
+
+  /**
+   * Resend email verification
+   */
+  resendEmailVerification(): Promise<void>
+
+  /**
+   * Update user profile (displayName, photoURL)
+   */
+  updateProfile(updates: Partial<Pick<User['profile'], 'displayName' | 'photoURL'>>): Promise<void>
+
+  /**
+   * Update user email (requires password)
+   */
+  updateEmail(newEmail: string, password: string): Promise<void>
+
+  /**
+   * Update user password (requires current password)
+   */
+  updatePassword(currentPassword: string, newPassword: string): Promise<void>
+
+  /**
+   * Delete user account (requires password)
+   */
+  deleteAccount(password: string): Promise<void>
+
+  /**
+   * Get current authenticated user
+   */
+  getCurrentUser(): FirebaseUser | null
+
+  /**
+   * 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>
+}

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

@@ -0,0 +1,143 @@
+/**
+ * File Repository Interface
+ * @description Defines 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>
+
+  /**
+   * 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[]>
+
+  /**
+   * 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
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Base Repository Interface
+ */
+
+export interface IBaseRepository<T> {
+  getById(id: string, parentPath?: string): Promise<T | null>;
+  getAll(constraints?: any[], parentPath?: string): Promise<T[]>;
+  create(id: string, data: Omit<T, 'id'>, parentPath?: string): Promise<void>;
+  update(id: string, data: Partial<T>, parentPath?: string): Promise<void>;
+  delete(id: string, parentPath?: string): Promise<void>;
+}