@umituz/web-firebase 1.0.5 → 2.0.1

package/dist/user.repository.interface-DS74TsJ5.d.ts

@@ -0,0 +1,298 @@
+import { UserCredential, User as User$1 } from 'firebase/auth';
+import { QueryConstraint } from 'firebase/firestore';
+
+/**
+ * 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
+ */
+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
+ */
+interface UserNotifications {
+    email: boolean;
+    push: boolean;
+    marketing: boolean;
+    security: boolean;
+    weeklyDigest: boolean;
+}
+/**
+ * User Privacy Settings
+ */
+interface UserPrivacy {
+    profileVisibility: 'public' | 'private';
+    showEmail: boolean;
+    showPhone: boolean;
+    dataSharing: boolean;
+}
+/**
+ * User Settings Value Object
+ */
+interface UserSettings {
+    theme: 'light' | 'dark' | 'system';
+    language: string;
+    timezone: string;
+    currency: string;
+    notifications: UserNotifications;
+    privacy: UserPrivacy;
+}
+/**
+ * User Subscription Value Object
+ */
+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
+ */
+interface AccountMetrics {
+    followers: number;
+    following: number;
+    posts: number;
+    engagement: number;
+    lastSyncedAt: number;
+}
+/**
+ * User Connected Account Entity
+ */
+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
+ */
+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
+ */
+interface PlatformBreakdown {
+    [platform: string]: {
+        posts: number;
+        engagement: number;
+        reach: number;
+    };
+}
+/**
+ * User Analytics Value Object
+ */
+interface UserAnalytics {
+    totalPosts: number;
+    totalEngagement: number;
+    totalReach: number;
+    topPerformingPosts: string[];
+    platformBreakdown: PlatformBreakdown;
+    lastCalculatedAt: number;
+}
+/**
+ * User Credits Value Object
+ */
+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
+ */
+interface User {
+    readonly profile: UserProfile;
+    settings: UserSettings;
+    subscription: UserSubscription;
+    connectedAccounts: UserConnectedAccount[];
+    content: UserContent[];
+    analytics: UserAnalytics;
+    credits: UserCredits;
+}
+/**
+ * Collection Constants
+ */
+declare const USER_COLLECTIONS: {
+    readonly USERS: "users";
+    readonly CONTENT: "content";
+    readonly ANALYTICS: "analytics";
+    readonly CONNECTED_ACCOUNTS: "connectedAccounts";
+};
+declare const USER_SUBCOLLECTIONS: {
+    readonly CONTENT: "content";
+    readonly ANALYTICS: "analytics";
+    readonly SCHEDULED: "scheduled";
+    readonly PUBLISHED: "published";
+    readonly DRAFTS: "drafts";
+};
+
+/**
+ * Authentication Repository Interface
+ * @description Defines contract for authentication operations
+ */
+
+/**
+ * Authentication Repository Interface
+ * Defines operations for user authentication and management
+ */
+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(): User$1 | null;
+    /**
+     * Subscribe to auth state changes
+     */
+    onAuthStateChanged(callback: (user: User$1 | 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>;
+}
+
+/**
+ * User Repository Interface
+ * @description Defines contract for user data operations
+ */
+
+/**
+ * User Repository Interface
+ * Defines operations for user data management
+ */
+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;
+}
+
+export { type AccountMetrics as A, type IAuthRepository as I, type PlatformBreakdown as P, USER_COLLECTIONS as U, type IUserRepository as a, USER_SUBCOLLECTIONS as b, type User as c, type UserAnalytics as d, type UserConnectedAccount as e, type UserContent as f, type UserCredits as g, type UserNotifications as h, type UserPrivacy as i, type UserProfile as j, type UserSettings as k, type UserSubscription as l };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@umituz/web-firebase",
-  "version": "1.0.5",
-  "description": "Universal Firebase utilities for web applications",
+  "version": "2.0.1",
+  "description": "Comprehensive Firebase integration with DDD architecture for web applications",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -15,17 +15,34 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
     },
-    "./domain": "./src/domain/index.ts",
-    "./infrastructure": "./src/infrastructure/index.ts",
-    "./presentation": "./src/presentation/index.ts"
+    "./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"
+    }
   },
   "files": [
     "dist",
     "src"
   ],
   "scripts": {
-    "build": "tsup src/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 --format cjs,esm --dts --watch --external react --external firebase",
+    "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"
   },
   "keywords": [
@@ -33,18 +50,27 @@
     "firestore",
     "auth",
     "storage",
+    "functions",
+    "analytics",
     "react",
-    "web"
+    "web",
+    "typescript",
+    "ddd",
+    "domain-driven-design",
+    "clean-architecture",
+    "repository-pattern",
+    "use-cases",
+    "hexagonal-architecture"
   ],
-  "author": "Antigravity",
+  "author": "umituz",
   "license": "MIT",
   "peerDependencies": {
-    "firebase": ">=10",
+    "firebase": ">=12",
     "react": ">=18"
   },
   "devDependencies": {
     "@types/react": "^18.2.0",
-    "firebase": "^11.0.0",
+    "firebase": "^12.11.0",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0"
   }

package/src/application/dto/auth.dto.ts

@@ -0,0 +1,69 @@
+/**
+ * Authentication DTOs
+ * @description Data Transfer Objects for authentication operations
+ */
+
+import type { UserCredential } from 'firebase/auth'
+
+/**
+ * Sign In DTO
+ */
+export interface SignInDTO {
+  email: string
+  password: string
+}
+
+/**
+ * Sign Up DTO
+ */
+export interface SignUpDTO {
+  email: string
+  password: string
+  displayName: string
+}
+
+/**
+ * Sign Up Result
+ */
+export interface SignUpResult extends UserCredential {
+  userId: string
+  emailVerified: boolean
+}
+
+/**
+ * Reset Password DTO
+ */
+export interface ResetPasswordDTO {
+  email: string
+}
+
+/**
+ * Update Profile DTO
+ */
+export interface UpdateProfileDTO {
+  displayName?: string
+  photoURL?: string
+}
+
+/**
+ * Update Email DTO
+ */
+export interface UpdateEmailDTO {
+  newEmail: string
+  currentPassword: string
+}
+
+/**
+ * Update Password DTO
+ */
+export interface UpdatePasswordDTO {
+  currentPassword: string
+  newPassword: string
+}
+
+/**
+ * Delete Account DTO
+ */
+export interface DeleteAccountDTO {
+  password: string
+}

package/src/application/dto/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Application Layer DTOs
+ * @description Data Transfer Objects for use cases
+ */
+
+export * from './auth.dto'
+export * from './user.dto'

package/src/application/dto/user.dto.ts

@@ -0,0 +1,64 @@
+/**
+ * User DTOs
+ * @description Data Transfer Objects for user operations
+ */
+
+import type { User } from '../../domain/entities/user.entity'
+
+/**
+ * Create User DTO
+ */
+export interface CreateUserDTO {
+  id: string
+  email: string
+  displayName: string
+  photoURL?: string
+  phoneNumber?: string
+  emailVerified: boolean
+}
+
+/**
+ * Update User DTO
+ */
+export interface UpdateUserDTO {
+  displayName?: string
+  photoURL?: string
+  phoneNumber?: string
+  theme?: 'light' | 'dark' | 'system'
+  language?: string
+  timezone?: string
+}
+
+/**
+ * Update User Settings DTO
+ */
+export interface UpdateUserSettingsDTO {
+  theme?: 'light' | 'dark' | 'system'
+  language?: string
+  timezone?: string
+  currency?: string
+  notifications?: Partial<User['settings']['notifications']>
+  privacy?: Partial<User['settings']['privacy']>
+}
+
+/**
+ * Update User Subscription DTO
+ */
+export interface UpdateUserSubscriptionDTO {
+  plan?: User['subscription']['plan']
+  status?: User['subscription']['status']
+  polarCustomerId?: string
+  polarSubscriptionId?: string
+  currentPeriodStart?: number
+  currentPeriodEnd?: number
+  cancelAtPeriodEnd?: boolean
+}
+
+/**
+ * User Query Result
+ */
+export interface UserQueryResult {
+  user: User | null
+  lastLoginAt?: number
+  createdAt?: number
+}

package/src/application/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Application Layer Public API
+ * @description Exports all use cases and DTOs
+ */
+
+export * from './dto'
+export * from './use-cases'

package/src/application/use-cases/auth/reset-password.use-case.ts

@@ -0,0 +1,66 @@
+/**
+ * Reset Password Use Case
+ * @description Handles password reset flow
+ */
+
+import type { IAuthRepository } from '../../../domain/interfaces/auth.repository.interface'
+import type { ResetPasswordDTO } from '../../dto/auth.dto'
+import { createAuthError, AuthErrorCode } from '../../../domain/errors/auth.errors'
+
+export class ResetPasswordUseCase {
+  constructor(private readonly authRepository: IAuthRepository) {}
+
+  /**
+   * Execute password reset use case
+   */
+  async execute(dto: ResetPasswordDTO): Promise<void> {
+    try {
+      // Validate input
+      this.validateDTO(dto)
+
+      // Send password reset email
+      await this.authRepository.sendPasswordReset(dto.email)
+    } catch (error) {
+      throw this.handleError(error)
+    }
+  }
+
+  /**
+   * Validate DTO
+   */
+  private validateDTO(dto: ResetPasswordDTO): void {
+    if (!dto.email) {
+      throw createAuthError(AuthErrorCode.PASSWORD_RESET_FAILED, 'Email is required')
+    }
+
+    // Email validation
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+    if (!emailRegex.test(dto.email)) {
+      throw createAuthError(AuthErrorCode.PASSWORD_RESET_FAILED, 'Invalid email format')
+    }
+  }
+
+  /**
+   * Handle errors
+   */
+  private handleError(error: unknown): Error {
+    if (error instanceof Error && 'code' in error) {
+      const code = (error as { code: string }).code
+
+      if (code === 'auth/invalid-email') {
+        return createAuthError(AuthErrorCode.PASSWORD_RESET_FAILED, 'Invalid email', error)
+      }
+
+      if (code === 'auth/user-not-found') {
+        // Don't reveal if user exists
+        return createAuthError(AuthErrorCode.PASSWORD_RESET_FAILED, 'Password reset email sent if account exists')
+      }
+
+      if (code === 'auth/too-many-requests') {
+        return createAuthError(AuthErrorCode.TOO_MANY_REQUESTS, 'Too many requests', error)
+      }
+    }
+
+    return createAuthError(AuthErrorCode.PASSWORD_RESET_FAILED, 'Password reset failed', error)
+  }
+}

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

@@ -0,0 +1,86 @@
+/**
+ * Sign In With Google Use Case
+ * @description Handles Google OAuth sign in/sign up
+ */
+
+import type { UserCredential } from 'firebase/auth'
+import type { IAuthRepository } from '../../../domain/interfaces/auth.repository.interface'
+import type { IUserRepository } from '../../../domain/interfaces/user.repository.interface'
+import type { CreateUserDTO } from '../../dto/user.dto'
+import { createAuthError, AuthErrorCode } from '../../../domain/errors/auth.errors'
+
+export class SignInWithGoogleUseCase {
+  constructor(
+    private readonly authRepository: IAuthRepository,
+    private readonly userRepository: IUserRepository
+  ) {}
+
+  /**
+   * Execute Google sign in use case
+   */
+  async execute(): Promise<UserCredential> {
+    try {
+      // Perform Google sign in
+      const result = await this.authRepository.signInWithGoogle()
+
+      // Check if user needs onboarding
+      const existingUser = await this.userRepository.getUser(result.user.uid)
+      if (!existingUser) {
+        // New user - create user document
+        const createUserDTO: CreateUserDTO = {
+          id: result.user.uid,
+          email: result.user.email || '',
+          displayName: result.user.displayName || '',
+          photoURL: result.user.photoURL || undefined,
+          phoneNumber: result.user.phoneNumber || undefined,
+          emailVerified: result.user.emailVerified,
+        }
+
+        await this.authRepository.createUserDocument(result.user.uid, createUserDTO)
+      }
+
+      return result
+    } catch (error) {
+      throw this.handleError(error)
+    }
+  }
+
+  /**
+   * Handle errors
+   */
+  private handleError(error: unknown): Error {
+    if (error instanceof Error && 'code' in error) {
+      const code = (error as { code: string }).code
+
+      if (code === 'auth/popup-closed-by-user') {
+        return createAuthError(AuthErrorCode.OAUTH_CANCELLED, 'Google sign in cancelled', error)
+      }
+
+      if (code === 'auth/popup-blocked') {
+        return createAuthError(AuthErrorCode.OAUTH_ERROR, 'Popup blocked by browser', error)
+      }
+
+      if (code === 'auth/account-exists-with-different-credential') {
+        return createAuthError(
+          AuthErrorCode.OAUTH_ACCOUNT_EXISTS,
+          'Account already exists with different credential',
+          error
+        )
+      }
+
+      if (code === 'auth/auth-domain-policy-required') {
+        return createAuthError(AuthErrorCode.OAUTH_ERROR, 'Auth domain not configured', error)
+      }
+
+      if (code === 'auth/unauthorized-domain') {
+        return createAuthError(AuthErrorCode.OAUTH_ERROR, 'Unauthorized domain', error)
+      }
+
+      if (code === 'auth/cancelled-popup-request') {
+        return createAuthError(AuthErrorCode.OAUTH_CANCELLED, 'Sign in cancelled', error)
+      }
+    }
+
+    return createAuthError(AuthErrorCode.OAUTH_ERROR, 'Google sign in failed', error)
+  }
+}