svelte-firekit 0.0.25 → 0.1.0

package/dist/services/user.svelte.js

@@ -0,0 +1,533 @@
+/**
+ * @fileoverview FirekitUser Store - Reactive user state management using Svelte 5 runes
+ * @module FirekitUserStore
+ * @version 1.0.0
+ */
+import { onAuthStateChanged, updateProfile, updateEmail, updatePassword, reload, sendEmailVerification, getIdToken } from 'firebase/auth';
+import { doc, setDoc, getDoc, serverTimestamp } from 'firebase/firestore';
+import { firebaseService } from '../firebase.js';
+import { FirekitAuthError, AuthErrorCode } from '../types/auth.js';
+import { mapFirebaseUserToProfile, updateUserInFirestore, createAuthError, validateCurrentUser } from '../utils/index.js';
+/**
+ * Reactive user store using Svelte 5 runes for state management.
+ * Provides real-time authentication state and user profile management.
+ *
+ * @class FirekitUserStore
+ * @example
+ * ```typescript
+ * import { firekitUser } from 'svelte-firekit';
+ *
+ * // Access reactive state
+ * $: if (firekitUser.isAuthenticated) {
+ *   console.log("User:", firekitUser.user);
+ * }
+ *
+ * // Update profile
+ * await firekitUser.updateDisplayName("John Doe");
+ *
+ * // Get extended user data
+ * const userData = await firekitUser.getExtendedUserData();
+ * ```
+ */
+class FirekitUserStore {
+    static instance;
+    auth = firebaseService.getAuthInstance();
+    firestore = firebaseService.getDbInstance();
+    // ========================================
+    // REACTIVE STATE (Svelte 5 Runes)
+    // ========================================
+    /** Current user profile state */
+    _user = $state(null);
+    /** Loading state indicator */
+    _loading = $state(true);
+    /** Authentication initialization state */
+    _initialized = $state(false);
+    /** Current error state */
+    _error = $state(null);
+    // ========================================
+    // DERIVED STATE
+    // ========================================
+    /** Derived: Whether user is authenticated (not anonymous) */
+    _isAuthenticated = $derived(this._user !== null && !this._user.isAnonymous);
+    /** Derived: Whether user is anonymous */
+    _isAnonymous = $derived(this._user?.isAnonymous ?? false);
+    /** Derived: Whether user's email is verified */
+    _isEmailVerified = $derived(this._user?.emailVerified ?? false);
+    /** Derived: User's primary email address */
+    _userEmail = $derived(this._user?.email ?? null);
+    /** Derived: User's display name */
+    _userDisplayName = $derived(this._user?.displayName ?? null);
+    /** Derived: User's photo URL */
+    _userPhotoURL = $derived(this._user?.photoURL ?? null);
+    /** Derived: User's unique ID */
+    _userId = $derived(this._user?.uid ?? null);
+    /** Derived: User's phone number */
+    _userPhoneNumber = $derived(this._user?.phoneNumber ?? null);
+    constructor() {
+        if (!this.auth) {
+            throw new Error('Firebase Auth instance not available');
+        }
+        if (!this.firestore) {
+            throw new Error('Firestore instance not available');
+        }
+        this.initializeAuthStateListener();
+    }
+    /**
+     * Gets singleton instance of FirekitUserStore
+     * @returns {FirekitUserStore} The FirekitUserStore instance
+     */
+    static getInstance() {
+        if (!FirekitUserStore.instance) {
+            FirekitUserStore.instance = new FirekitUserStore();
+        }
+        return FirekitUserStore.instance;
+    }
+    /**
+     * Initializes the authentication state listener
+     * @private
+     */
+    initializeAuthStateListener() {
+        onAuthStateChanged(this.auth, (firebaseUser) => {
+            this._user = firebaseUser ? this.mapFirebaseUserToProfile(firebaseUser) : null;
+            this._loading = false;
+            this._initialized = true;
+            this._error = null;
+        }, (error) => {
+            console.error('Auth state change error:', error);
+            this._error = error;
+            this._loading = false;
+            this._initialized = true;
+        });
+    }
+    /**
+     * Maps Firebase User to UserProfile interface
+     * @private
+     */
+    mapFirebaseUserToProfile(user) {
+        return mapFirebaseUserToProfile(user);
+    }
+    /**
+     * Updates user data in Firestore
+     * @private
+     */
+    async updateUserInFirestore(user) {
+        await updateUserInFirestore(this.firestore, user);
+    }
+    // ========================================
+    // PUBLIC GETTERS (Reactive State)
+    // ========================================
+    /** Current user profile */
+    get user() {
+        return this._user;
+    }
+    /** Current loading state */
+    get loading() {
+        return this._loading;
+    }
+    /** Whether auth has been initialized */
+    get initialized() {
+        return this._initialized;
+    }
+    /** Current error state */
+    get error() {
+        return this._error;
+    }
+    /** Whether user is authenticated (not anonymous) */
+    get isAuthenticated() {
+        return this._isAuthenticated;
+    }
+    /** Whether user is anonymous */
+    get isAnonymous() {
+        return this._isAnonymous;
+    }
+    /** Whether user's email is verified */
+    get isEmailVerified() {
+        return this._isEmailVerified;
+    }
+    /** User's email address */
+    get email() {
+        return this._userEmail;
+    }
+    /** User's display name */
+    get displayName() {
+        return this._userDisplayName;
+    }
+    /** User's photo URL */
+    get photoURL() {
+        return this._userPhotoURL;
+    }
+    /** User's unique ID */
+    get uid() {
+        return this._userId;
+    }
+    /** User's phone number */
+    get phoneNumber() {
+        return this._userPhoneNumber;
+    }
+    // ========================================
+    // PROFILE UPDATE METHODS
+    // ========================================
+    /**
+     * Updates user's display name
+     * @param {string} displayName New display name
+     * @returns {Promise<void>} Promise that resolves when update completes
+     * @throws {FirekitAuthError} If update fails
+     *
+     * @example
+     * ```typescript
+     * await firekitUser.updateDisplayName("John Doe");
+     * ```
+     */
+    async updateDisplayName(displayName) {
+        const currentUser = validateCurrentUser(this.auth);
+        try {
+            this._loading = true;
+            await updateProfile(currentUser, { displayName });
+            await this.updateUserInFirestore(currentUser);
+            // Update local state
+            if (this._user) {
+                this._user = { ...this._user, displayName };
+            }
+        }
+        catch (error) {
+            this._error = error;
+            throw createAuthError(error, 'update display name');
+        }
+        finally {
+            this._loading = false;
+        }
+    }
+    /**
+     * Updates user's photo URL
+     * @param {string} photoURL New photo URL
+     * @returns {Promise<void>} Promise that resolves when update completes
+     * @throws {FirekitAuthError} If update fails
+     *
+     * @example
+     * ```typescript
+     * await firekitUser.updatePhotoURL("https://example.com/photo.jpg");
+     * ```
+     */
+    async updatePhotoURL(photoURL) {
+        const currentUser = validateCurrentUser(this.auth);
+        try {
+            this._loading = true;
+            await updateProfile(currentUser, { photoURL });
+            await this.updateUserInFirestore(currentUser);
+            // Update local state
+            if (this._user) {
+                this._user = { ...this._user, photoURL };
+            }
+        }
+        catch (error) {
+            this._error = error;
+            throw createAuthError(error, 'update photo URL');
+        }
+        finally {
+            this._loading = false;
+        }
+    }
+    /**
+     * Updates user's profile data
+     * @param {UserProfileUpdateData} profileData Profile data to update
+     * @returns {Promise<void>} Promise that resolves when update completes
+     * @throws {FirekitAuthError} If update fails
+     *
+     * @example
+     * ```typescript
+     * await firekitUser.updateProfile({
+     *   displayName: "John Smith",
+     *   photoURL: "https://example.com/new-photo.jpg"
+     * });
+     * ```
+     */
+    async updateProfile(profileData) {
+        const currentUser = validateCurrentUser(this.auth);
+        try {
+            this._loading = true;
+            await updateProfile(currentUser, profileData);
+            await this.updateUserInFirestore(currentUser);
+            // Update local state
+            if (this._user) {
+                this._user = {
+                    ...this._user,
+                    displayName: profileData.displayName ?? this._user.displayName,
+                    photoURL: profileData.photoURL ?? this._user.photoURL
+                };
+            }
+        }
+        catch (error) {
+            this._error = error;
+            throw createAuthError(error, 'update profile');
+        }
+        finally {
+            this._loading = false;
+        }
+    }
+    /**
+     * Updates user's email address
+     * @param {string} newEmail New email address
+     * @returns {Promise<void>} Promise that resolves when update completes
+     * @throws {FirekitAuthError} If update fails
+     *
+     * @example
+     * ```typescript
+     * await firekitUser.updateEmail("newemail@example.com");
+     * ```
+     */
+    async updateEmail(newEmail) {
+        const currentUser = validateCurrentUser(this.auth);
+        try {
+            this._loading = true;
+            await updateEmail(currentUser, newEmail);
+            await this.updateUserInFirestore(currentUser);
+            // Update local state
+            if (this._user) {
+                this._user = { ...this._user, email: newEmail, emailVerified: false };
+            }
+        }
+        catch (error) {
+            this._error = error;
+            throw createAuthError(error, 'update email');
+        }
+        finally {
+            this._loading = false;
+        }
+    }
+    /**
+     * Updates user's password
+     * @param {string} newPassword New password
+     * @returns {Promise<void>} Promise that resolves when update completes
+     * @throws {FirekitAuthError} If update fails
+     *
+     * @example
+     * ```typescript
+     * await firekitUser.updatePassword("newSecurePassword123");
+     * ```
+     */
+    async updatePassword(newPassword) {
+        const currentUser = validateCurrentUser(this.auth);
+        try {
+            this._loading = true;
+            await updatePassword(currentUser, newPassword);
+        }
+        catch (error) {
+            this._error = error;
+            throw createAuthError(error, 'update password');
+        }
+        finally {
+            this._loading = false;
+        }
+    }
+    // ========================================
+    // EMAIL VERIFICATION METHODS
+    // ========================================
+    /**
+     * Sends email verification to current user
+     * @returns {Promise<void>} Promise that resolves when verification email is sent
+     * @throws {FirekitAuthError} If sending fails
+     *
+     * @example
+     * ```typescript
+     * await firekitUser.sendEmailVerification();
+     * ```
+     */
+    async sendEmailVerification() {
+        const currentUser = validateCurrentUser(this.auth);
+        try {
+            await sendEmailVerification(currentUser);
+        }
+        catch (error) {
+            this._error = error;
+            throw createAuthError(error, 'send email verification');
+        }
+    }
+    /**
+     * Reloads user to get updated email verification status
+     * @returns {Promise<void>} Promise that resolves when user is reloaded
+     * @throws {FirekitAuthError} If reload fails
+     *
+     * @example
+     * ```typescript
+     * await firekitUser.reloadUser();
+     * ```
+     */
+    async reloadUser() {
+        const currentUser = validateCurrentUser(this.auth);
+        try {
+            this._loading = true;
+            await reload(currentUser);
+            await this.updateUserInFirestore(currentUser);
+            // Update local state with reloaded data
+            this._user = this.mapFirebaseUserToProfile(currentUser);
+        }
+        catch (error) {
+            this._error = error;
+            throw createAuthError(error, 'reload user');
+        }
+        finally {
+            this._loading = false;
+        }
+    }
+    // ========================================
+    // TOKEN METHODS
+    // ========================================
+    /**
+     * Gets the current user's ID token
+     * @param {boolean} [forceRefresh=false] Whether to force token refresh
+     * @returns {Promise<string>} Promise resolving to ID token
+     * @throws {FirekitAuthError} If getting token fails
+     *
+     * @example
+     * ```typescript
+     * const token = await firekitUser.getIdToken();
+     * ```
+     */
+    async getIdToken(forceRefresh = false) {
+        const currentUser = validateCurrentUser(this.auth);
+        try {
+            return await getIdToken(currentUser, forceRefresh);
+        }
+        catch (error) {
+            this._error = error;
+            throw createAuthError(error, 'get ID token');
+        }
+    }
+    // ========================================
+    // FIRESTORE EXTENDED DATA METHODS
+    // ========================================
+    /**
+     * Gets extended user data from Firestore
+     * @returns {Promise<ExtendedUserData | null>} Promise resolving to extended user data
+     *
+     * @example
+     * ```typescript
+     * const userData = await firekitUser.getExtendedUserData();
+     * console.log(userData?.preferences);
+     * ```
+     */
+    async getExtendedUserData() {
+        if (!this._user?.uid) {
+            return null;
+        }
+        try {
+            const userRef = doc(this.firestore, 'users', this._user.uid);
+            const userDoc = await getDoc(userRef);
+            if (userDoc.exists()) {
+                return userDoc.data();
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('Failed to get extended user data:', error);
+            this._error = error;
+            return null;
+        }
+    }
+    /**
+     * Updates extended user data in Firestore
+     * @param {Partial<ExtendedUserData>} data Data to update
+     * @returns {Promise<void>} Promise that resolves when update completes
+     *
+     * @example
+     * ```typescript
+     * await firekitUser.updateExtendedUserData({
+     *   preferences: { theme: 'dark', language: 'en' },
+     *   settings: { notifications: true }
+     * });
+     * ```
+     */
+    async updateExtendedUserData(data) {
+        if (!this._user?.uid) {
+            throw new FirekitAuthError(AuthErrorCode.USER_NOT_FOUND, 'No authenticated user found.');
+        }
+        try {
+            const userRef = doc(this.firestore, 'users', this._user.uid);
+            await setDoc(userRef, {
+                ...data,
+                updatedAt: serverTimestamp()
+            }, { merge: true });
+        }
+        catch (error) {
+            this._error = error;
+            throw createAuthError(error, 'update user data');
+        }
+    }
+    // ========================================
+    // UTILITY METHODS
+    // ========================================
+    /**
+     * Waits for authentication to initialize
+     * @returns {Promise<UserProfile | null>} Promise that resolves when auth is initialized
+     *
+     * @example
+     * ```typescript
+     * const user = await firekitUser.waitForAuth();
+     * if (user) {
+     *   console.log("User is authenticated");
+     * }
+     * ```
+     */
+    async waitForAuth() {
+        return new Promise((resolve) => {
+            if (this._initialized) {
+                resolve(this._user);
+                return;
+            }
+            // Create a one-time watcher
+            const checkInitialized = () => {
+                if (this._initialized) {
+                    resolve(this._user);
+                }
+                else {
+                    // Check again in next tick
+                    setTimeout(checkInitialized, 10);
+                }
+            };
+            checkInitialized();
+        });
+    }
+    /**
+     * Clears any error state
+     */
+    clearError() {
+        this._error = null;
+    }
+    /**
+     * Manually sets loading state (use with caution)
+     * @param {boolean} loading Loading state
+     */
+    setLoading(loading) {
+        this._loading = loading;
+    }
+    /**
+     * Resets the store to initial state
+     */
+    reset() {
+        this._user = null;
+        this._loading = true;
+        this._initialized = false;
+        this._error = null;
+    }
+}
+/**
+ * Pre-initialized singleton instance of FirekitUserStore.
+ * Provides reactive user state management for Svelte applications.
+ *
+ * @example
+ * ```typescript
+ * import { firekitUser } from 'svelte-firekit';
+ *
+ * // In a Svelte component
+ * $: if (firekitUser.isAuthenticated) {
+ *   console.log("Welcome:", firekitUser.displayName);
+ * }
+ *
+ * // Update profile
+ * await firekitUser.updateDisplayName("John Doe");
+ *
+ * // Get extended data
+ * const userData = await firekitUser.getExtendedUserData();
+ * ```
+ */
+export const firekitUser = FirekitUserStore.getInstance();

package/dist/types/auth.d.ts

@@ -0,0 +1,158 @@
+/**
+ * @fileoverview Authentication types and interfaces for FirekitAuth
+ * @module AuthTypes
+ * @version 1.0.0
+ */
+/**
+ * User profile interface with all Firebase user properties
+ */
+export interface UserProfile {
+    uid: string;
+    email: string | null;
+    displayName: string | null;
+    photoURL: string | null;
+    phoneNumber: string | null;
+    emailVerified: boolean;
+    isAnonymous: boolean;
+    providerId: string;
+    metadata: {
+        creationTime?: string;
+        lastSignInTime?: string;
+    };
+    providerData: Array<{
+        providerId: string;
+        uid: string;
+        displayName: string | null;
+        email: string | null;
+        phoneNumber: string | null;
+        photoURL: string | null;
+    }>;
+    customClaims?: Record<string, any>;
+}
+/**
+ * Authentication state interface
+ */
+export interface AuthState {
+    user: UserProfile | null;
+    loading: boolean;
+    initialized: boolean;
+}
+/**
+ * Password update result interface
+ */
+export interface PasswordUpdateResult {
+    success: boolean;
+    message: string;
+    code?: string;
+}
+/**
+ * Account deletion result interface
+ */
+export interface AccountDeletionResult {
+    success: boolean;
+    message: string;
+}
+/**
+ * Phone verification result interface
+ */
+export interface PhoneVerificationResult {
+    verificationId: string;
+    confirm: (code: string) => Promise<UserProfile>;
+}
+/**
+ * User registration data interface
+ */
+export interface UserRegistrationData {
+    email: string;
+    password: string;
+    displayName?: string;
+    photoURL?: string;
+}
+/**
+ * User profile update data interface
+ */
+export interface UserProfileUpdateData {
+    displayName?: string;
+    photoURL?: string;
+}
+/**
+ * OAuth provider types
+ */
+export type OAuthProviderType = 'google' | 'facebook' | 'apple' | 'microsoft' | 'github' | 'twitter';
+/**
+ * Authentication method types
+ */
+export type AuthMethodType = 'email' | 'phone' | 'google' | 'facebook' | 'apple' | 'microsoft' | 'github' | 'twitter' | 'anonymous';
+/**
+ * Authentication event types
+ */
+export type AuthEventType = 'signIn' | 'signOut' | 'signUp' | 'passwordReset' | 'emailVerification' | 'profileUpdate' | 'accountDeletion' | 'error';
+/**
+ * Authentication event data interface
+ */
+export interface AuthEventData {
+    type: AuthEventType;
+    user?: UserProfile | null;
+    method?: AuthMethodType;
+    error?: FirekitAuthError;
+    timestamp: Date;
+}
+/**
+ * Authentication configuration interface
+ */
+export interface AuthConfig {
+    /** Enable automatic Firestore user data sync */
+    enableFirestoreSync?: boolean;
+    /** Custom Firestore collection path for users */
+    usersCollectionPath?: string;
+    /** Enable email verification on registration */
+    requireEmailVerification?: boolean;
+    /** Custom error message overrides */
+    errorMessages?: Partial<Record<AuthErrorCode, string>>;
+    /** Enable analytics tracking */
+    enableAnalytics?: boolean;
+}
+/**
+ * Authentication error codes enum
+ */
+export declare enum AuthErrorCode {
+    EMAIL_ALREADY_IN_USE = "auth/email-already-in-use",
+    INVALID_EMAIL = "auth/invalid-email",
+    USER_NOT_FOUND = "auth/user-not-found",
+    WRONG_PASSWORD = "auth/wrong-password",
+    WEAK_PASSWORD = "auth/weak-password",
+    TOO_MANY_REQUESTS = "auth/too-many-requests",
+    POPUP_CLOSED = "auth/popup-closed-by-user",
+    NETWORK_REQUEST_FAILED = "auth/network-request-failed",
+    USER_DISABLED = "auth/user-disabled",
+    OPERATION_NOT_ALLOWED = "auth/operation-not-allowed",
+    INVALID_VERIFICATION_CODE = "auth/invalid-verification-code",
+    INVALID_VERIFICATION_ID = "auth/invalid-verification-id",
+    REQUIRES_RECENT_LOGIN = "auth/requires-recent-login",
+    EXPIRED_ACTION_CODE = "auth/expired-action-code",
+    INVALID_ACTION_CODE = "auth/invalid-action-code",
+    MISSING_EMAIL = "auth/missing-email",
+    MISSING_PASSWORD = "auth/missing-password",
+    INVALID_PHONE_NUMBER = "auth/invalid-phone-number",
+    MISSING_PHONE_NUMBER = "auth/missing-phone-number",
+    QUOTA_EXCEEDED = "auth/quota-exceeded",
+    APP_NOT_AUTHORIZED = "auth/app-not-authorized",
+    KEYBOARD_NOT_SUPPORTED = "auth/keychain-error",
+    INTERNAL_ERROR = "auth/internal-error"
+}
+/**
+ * Custom authentication error class
+ */
+export declare class FirekitAuthError extends Error {
+    code: AuthErrorCode | string;
+    originalError?: any | undefined;
+    constructor(code: AuthErrorCode | string, message: string, originalError?: any | undefined);
+    /**
+     * Get user-friendly error message
+     */
+    getFriendlyMessage(): string;
+    /**
+     * Check if error is retryable
+     */
+    isRetryable(): boolean;
+}