@umituz/web-firebase 2.1.1 → 3.0.1

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.1",
+  "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/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'

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

@@ -1,75 +1,48 @@
 /**
  * User Repository Interface
- * @description Defines contract for user data operations
+ * @description Generic 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
+   * Get document by ID
    */
-  updateUser(userId: string, data: Partial<User>): Promise<void>
+  getById<T>(userId: string): Promise<T | null>
 
   /**
-   * Delete user
+   * Get document by field
    */
-  deleteUser(userId: string): Promise<void>
+  getByField<T>(collectionPath: string, field: string, value: any): Promise<T | null>
 
   /**
-   * Update user profile
+   * Create document
    */
-  updateProfile(userId: string, updates: Partial<Pick<User['profile'], 'displayName' | 'photoURL' | 'phoneNumber'>>): Promise<void>
+  create(userId: string, data: any): Promise<void>
 
   /**
-   * Update user settings
+   * Update document
    */
-  updateSettings(userId: string, settings: Partial<User['settings']>): Promise<void>
+  update(userId: string, data: any, options?: { merge?: boolean }): Promise<void>
 
   /**
-   * Update user subscription
+   * Delete document
    */
-  updateSubscription(
-    userId: string,
-    subscription: Partial<User['subscription']>
-  ): Promise<void>
+  delete(userId: string): Promise<void>
 
   /**
-   * Update last login timestamp
+   * Query collection with constraints
    */
-  updateLastLogin(userId: string): Promise<void>
+  query<T>(collectionPath: string, constraints: QueryConstraint[]): Promise<T[]>
 
   /**
-   * Query users with constraints
+   * Subscribe to document changes
    */
-  queryUsers(constraints: QueryConstraint[]): Promise<User[]>
+  subscribeToDoc<T>(docPath: string, callback: (data: T | null) => void): () => void
 
   /**
-   * Subscribe to user document changes
+   * Subscribe to collection changes
    */
-  subscribeToUser(
-    userId: string,
-    callback: (user: User | null) => void,
-    onError?: (error: Error) => void
-  ): () => void
+  subscribeToCollection<T>(collectionPath: string, callback: (data: T[]) => void, constraints?: QueryConstraint[]): () => void
 }

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'