@umituz/web-firebase 2.1.1 → 3.0.0

package/package.json

@@ -1,49 +1,25 @@
 {
   "name": "@umituz/web-firebase",
-  "version": "2.1.1",
-  "description": "Comprehensive Firebase integration with DDD architecture for web applications",
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "version": "3.0.0",
+  "description": "Comprehensive Firebase integration with domain-based architecture for web applications",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
   "sideEffects": false,
   "publishConfig": {
     "access": "public"
   },
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
-    },
-    "./domain": {
-      "types": "./dist/domain/index.d.ts",
-      "import": "./dist/domain/index.mjs",
-      "require": "./dist/domain/index.js"
-    },
-    "./application": {
-      "types": "./dist/application/index.d.ts",
-      "import": "./dist/application/index.mjs",
-      "require": "./dist/application/index.js"
-    },
-    "./infrastructure": {
-      "types": "./dist/infrastructure/index.d.ts",
-      "import": "./dist/infrastructure/index.mjs",
-      "require": "./dist/infrastructure/index.js"
-    },
-    "./presentation": {
-      "types": "./dist/presentation/index.d.ts",
-      "import": "./dist/presentation/index.mjs",
-      "require": "./dist/presentation/index.js"
-    }
+    ".": "./src/index.ts",
+    "./auth": "./src/domains/auth/index.ts",
+    "./firestore": "./src/domains/firestore/index.ts",
+    "./storage": "./src/domains/storage/index.ts",
+    "./package.json": "./package.json"
   },
   "files": [
-    "dist",
     "src"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/domain/index.ts src/application/index.ts src/infrastructure/index.ts src/presentation/index.ts --format cjs,esm --dts --clean --external react --external firebase --external firebase/app --external firebase/auth --external firebase/firestore --external firebase/storage --external firebase/functions",
-    "dev": "tsup src/index.ts src/domain/index.ts src/application/index.ts src/infrastructure/index.ts src/presentation/index.ts --format cjs,esm --dts --watch --external react --external firebase",
-    "lint": "tsc --noEmit"
+    "typecheck": "tsc --noEmit"
   },
   "keywords": [
     "firebase",
@@ -57,10 +33,8 @@
     "typescript",
     "ddd",
     "domain-driven-design",
-    "clean-architecture",
-    "repository-pattern",
-    "use-cases",
-    "hexagonal-architecture"
+    "package-driven",
+    "repository-pattern"
   ],
   "author": "umituz",
   "license": "MIT",
@@ -71,7 +45,6 @@
   "devDependencies": {
     "@types/react": "^18.2.0",
     "firebase": "^12.11.0",
-    "tsup": "^8.0.0",
     "typescript": "^5.0.0"
   }
 }

package/src/domains/auth/entities/index.ts

@@ -0,0 +1,60 @@
+/**
+ * Auth Domain Entities
+ * @description Core authentication-related entities
+ */
+
+import type { User as FirebaseUser } from 'firebase/auth'
+
+/**
+ * Auth User Entity
+ * Wrapper around Firebase User with application-specific data
+ */
+export interface AuthUser {
+  readonly uid: string
+  readonly email: string | null
+  readonly emailVerified: boolean
+  readonly displayName: string | null
+  readonly photoURL: string | null
+  readonly phoneNumber: string | null
+  readonly isAnonymous: boolean
+  readonly tenantId: string | null
+  readonly providerId: string
+  readonly metadata: {
+    readonly creationTime?: number
+    readonly lastSignInTime?: number
+  }
+}
+
+/**
+ * Auth State Entity
+ * Current authentication state
+ */
+export interface AuthState {
+  readonly user: AuthUser | null
+  readonly isLoading: boolean
+  readonly isInitialized: boolean
+  readonly error: Error | null
+}
+
+/**
+ * Convert Firebase User to Auth User
+ */
+export function toAuthUser(firebaseUser: FirebaseUser | null): AuthUser | null {
+  if (!firebaseUser) return null
+
+  return {
+    uid: firebaseUser.uid,
+    email: firebaseUser.email,
+    emailVerified: firebaseUser.emailVerified,
+    displayName: firebaseUser.displayName,
+    photoURL: firebaseUser.photoURL,
+    phoneNumber: firebaseUser.phoneNumber,
+    isAnonymous: firebaseUser.isAnonymous,
+    tenantId: firebaseUser.tenantId,
+    providerId: firebaseUser.providerId,
+    metadata: {
+      creationTime: firebaseUser.metadata.creationTime ? new Date(firebaseUser.metadata.creationTime).getTime() : undefined,
+      lastSignInTime: firebaseUser.metadata.lastSignInTime ? new Date(firebaseUser.metadata.lastSignInTime).getTime() : undefined,
+    },
+  }
+}

package/src/domains/auth/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Auth Domain
+ * Complete Firebase Authentication integration
+ */
+
+// Entities
+export * from './entities'
+
+// Types
+export * from './types'
+
+// Services
+export * from './services'

package/src/domains/auth/services/auth.service.ts

@@ -0,0 +1,245 @@
+/**
+ * Auth Service
+ * @description Firebase Auth implementation of IAuthService
+ */
+
+import {
+  signInWithEmailAndPassword,
+  signInWithPopup,
+  createUserWithEmailAndPassword,
+  signOut as firebaseSignOut,
+  sendPasswordResetEmail,
+  sendEmailVerification,
+  updateProfile as updateAuthProfile,
+  updateEmail as updateAuthEmail,
+  updatePassword as updateAuthPassword,
+  reauthenticateWithCredential,
+  EmailAuthProvider,
+  UserCredential,
+} from 'firebase/auth'
+import { GoogleAuthProvider } from 'firebase/auth'
+import { getFirebaseAuth } from '../../../infrastructure/firebase/client'
+import type { IAuthService } from '../types'
+import type { AuthUser } from '../entities'
+
+class AuthService implements IAuthService {
+  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 new Error('Sign out failed')
+    }
+  }
+
+  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 new Error('No user logged in')
+      }
+      await sendEmailVerification(user)
+    } catch (error) {
+      throw new Error('Failed to resend verification')
+    }
+  }
+
+  // Profile Management
+
+  async updateProfile(updates: { displayName?: string; photoURL?: string }): Promise<void> {
+    try {
+      const user = this.auth.currentUser
+      if (!user) {
+        throw new Error('No user logged in')
+      }
+
+      await updateAuthProfile(user, updates)
+    } catch (error) {
+      throw new Error('Profile update failed')
+    }
+  }
+
+  async updateEmail(newEmail: string, password: string): Promise<void> {
+    try {
+      const user = this.auth.currentUser
+      if (!user || !user.email) {
+        throw new Error('No user logged in')
+      }
+
+      const credential = EmailAuthProvider.credential(user.email, password)
+      await reauthenticateWithCredential(user, credential)
+      await updateAuthEmail(user, newEmail)
+    } catch (error) {
+      throw new Error('Email update failed')
+    }
+  }
+
+  async updatePassword(currentPassword: string, newPassword: string): Promise<void> {
+    try {
+      const user = this.auth.currentUser
+      if (!user || !user.email) {
+        throw new Error('No user logged in')
+      }
+
+      const credential = EmailAuthProvider.credential(user.email, currentPassword)
+      await reauthenticateWithCredential(user, credential)
+      await updateAuthPassword(user, newPassword)
+    } catch (error) {
+      throw new Error('Password update failed')
+    }
+  }
+
+  async deleteAccount(password: string): Promise<void> {
+    try {
+      const user = this.auth.currentUser
+      if (!user || !user.email) {
+        throw new Error('No user logged in')
+      }
+
+      const credential = EmailAuthProvider.credential(user.email, password)
+      await reauthenticateWithCredential(user, credential)
+      await user.delete()
+    } catch (error) {
+      throw new Error('Account deletion failed')
+    }
+  }
+
+  // State Management
+
+  getCurrentUser(): AuthUser | null {
+    const user = this.auth.currentUser
+    if (!user) return null
+
+    return {
+      uid: user.uid,
+      email: user.email,
+      emailVerified: user.emailVerified,
+      displayName: user.displayName,
+      photoURL: user.photoURL,
+      phoneNumber: user.phoneNumber,
+      isAnonymous: user.isAnonymous,
+      tenantId: user.tenantId,
+      providerId: user.providerId,
+      metadata: {
+        creationTime: user.metadata.creationTime ? new Date(user.metadata.creationTime).getTime() : undefined,
+        lastSignInTime: user.metadata.lastSignInTime ? new Date(user.metadata.lastSignInTime).getTime() : undefined,
+      },
+    }
+  }
+
+  onAuthStateChanged(
+    callback: (user: AuthUser | null) => void,
+    onError?: (error: Error) => void
+  ): () => void {
+    return this.auth.onAuthStateChanged(
+      (user) => {
+        callback(
+          user
+            ? {
+                uid: user.uid,
+                email: user.email,
+                emailVerified: user.emailVerified,
+                displayName: user.displayName,
+                photoURL: user.photoURL,
+                phoneNumber: user.phoneNumber,
+                isAnonymous: user.isAnonymous,
+                tenantId: user.tenantId,
+                providerId: user.providerId,
+                metadata: {
+                  creationTime: user.metadata.creationTime ? new Date(user.metadata.creationTime).getTime() : undefined,
+                  lastSignInTime: user.metadata.lastSignInTime ? new Date(user.metadata.lastSignInTime).getTime() : undefined,
+                },
+              }
+            : null
+        )
+      },
+      (error) => {
+        onError?.(error as Error)
+      }
+    )
+  }
+
+  /**
+   * 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':
+        case 'auth/wrong-password':
+        case 'auth/invalid-credential':
+          return new Error('Invalid credentials')
+        case 'auth/email-already-in-use':
+          return new Error('Email already in use')
+        case 'auth/weak-password':
+          return new Error('Password is too weak')
+        case 'auth/invalid-email':
+          return new Error('Invalid email')
+        case 'auth/user-disabled':
+          return new Error('Account disabled')
+        case 'auth/too-many-requests':
+          return new Error('Too many requests')
+        case 'auth/popup-closed-by-user':
+          return new Error('Sign in cancelled')
+        default:
+          return new Error(`Auth error: ${code}`)
+      }
+    }
+
+    return new Error('Unknown auth error')
+  }
+}
+
+// Export class and singleton instance
+export const authService = new AuthService()

package/src/domains/auth/services/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Auth Domain Services
+ * Subpath: @umituz/web-firebase/auth
+ */
+
+export { authService } from './auth.service'
+export type { IAuthService } from '../types'

package/src/domains/auth/types/auth-service.interface.ts

@@ -0,0 +1,72 @@
+/**
+ * Auth Service Interface
+ * @description Abstract interface for authentication operations
+ */
+
+import type { UserCredential } from 'firebase/auth'
+import type { AuthUser } from '../entities'
+
+export interface IAuthService {
+  /**
+   * 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: { displayName?: string; photoURL?: string }): 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(): AuthUser | null
+
+  /**
+   * Subscribe to auth state changes
+   */
+  onAuthStateChanged(
+    callback: (user: AuthUser | null) => void,
+    onError?: (error: Error) => void
+  ): () => void
+}

package/src/domains/auth/types/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Auth Domain Types
+ */
+
+export * from './auth-service.interface';

package/src/domains/firestore/entities/index.ts

@@ -0,0 +1,82 @@
+/**
+ * Firestore Domain Entities
+ * @description Core Firestore-related entities
+ */
+
+/**
+ * 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
+}
+
+/**
+ * User Aggregate Root
+ * Main user document containing all user-related data
+ */
+export interface User {
+  readonly profile: UserProfile
+  settings: UserSettings
+  subscription: UserSubscription
+  connectedAccounts?: any[]
+  content?: any[]
+  analytics?: any
+  credits?: any
+}

package/src/domains/firestore/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Firestore Domain
+ * Complete Cloud Firestore integration
+ */
+
+// Entities
+export * from './entities'
+
+// Types
+export * from './types'
+
+// Services
+export * from './services'