svelte-firekit 0.0.9 → 0.0.11

package/dist/firebase/auth/auth-manager.svelte.js

@@ -0,0 +1,257 @@
+import { browser } from "$app/environment";
+import { goto } from "$app/navigation";
+import { firebaseService } from "../firebase.js";
+import { toast } from "svelte-sonner";
+import { onAuthStateChanged, updateCurrentUser, updateEmail, updatePassword, updatePhoneNumber, updateProfile, } from "firebase/auth";
+import { doc, getDoc, setDoc, updateDoc, } from "firebase/firestore";
+import { firekitAuth } from "./auth.js";
+export class FirekitAuthManager {
+    static instance;
+    // User-related states
+    _user = $state();
+    _userData = $state(null);
+    _claims = $state({});
+    _initialized = $state(false);
+    _initPromise = null;
+    // Auth-Guard related states
+    _loading = $state(true);
+    _error = $state(null);
+    _lastValidationTime = 0;
+    VALIDATION_THROTTLE = 1000; // 1 second
+    // Derived states
+    isLoggedIn = $derived(Boolean(this._user));
+    uid = $derived(this._user?.uid);
+    email = $derived(this._user?.email);
+    displayName = $derived(this._user?.displayName);
+    photoURL = $derived(this._user?.photoURL);
+    emailVerified = $derived(this._user?.emailVerified);
+    claims = $derived(this._claims);
+    data = $derived(this._userData);
+    initialized = $derived(this._initialized);
+    constructor() {
+        if (browser) {
+            this.initialize();
+        }
+    }
+    static getInstance() {
+        if (!FirekitAuthManager.instance) {
+            FirekitAuthManager.instance = new FirekitAuthManager();
+        }
+        return FirekitAuthManager.instance;
+    }
+    async initialize() {
+        if (this._initialized)
+            return;
+        this._initPromise = new Promise((resolve) => {
+            onAuthStateChanged(firebaseService.getAuthInstance(), async (user) => {
+                this._user = user;
+                if (user) {
+                    await Promise.all([this.loadUserData(), this.loadUserClaims()]);
+                }
+                else {
+                    this._userData = null;
+                    this._claims = {};
+                }
+                this._initialized = true;
+                resolve();
+            });
+        });
+    }
+    async waitForInit() {
+        if (this._initialized)
+            return;
+        return this._initPromise || Promise.resolve();
+    }
+    async loadUserData() {
+        if (!this._user?.uid)
+            return;
+        const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
+        const docSnap = await getDoc(docRef);
+        if (docSnap.exists()) {
+            this._userData = docSnap.data();
+        }
+        else {
+            const initialData = {
+                displayName: this._user.displayName || "",
+                email: this._user.email || "",
+                photoURL: this._user.photoURL || "",
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                isProfileComplete: false,
+            };
+            await this.saveUserData(initialData);
+        }
+    }
+    async loadUserClaims() {
+        if (!this._user)
+            return;
+        const tokenResult = await this._user.getIdTokenResult();
+        this._claims = tokenResult.claims;
+    }
+    get user() {
+        return this._user;
+    }
+    async updateEmailUser(email) {
+        if (!this._user)
+            throw new Error("No authenticated user");
+        try {
+            await updateEmail(this._user, email);
+            await this.updateUserData({ email });
+            toast.success("Email updated successfully!", {
+                description: "Please note that you will be logged out, and you will need to log in again using your new email address.",
+            });
+            setTimeout(async () => {
+                await firekitAuth.logOut();
+            }, 4500);
+        }
+        catch (error) {
+            toast.error(error.message);
+        }
+    }
+    async updatePassword(password) {
+        if (!this._user)
+            throw new Error("No authenticated user");
+        await updatePassword(this._user, password);
+    }
+    async updateProfileInfo({ displayName, photoURL, }) {
+        if (!this._user)
+            throw new Error("No authenticated user");
+        if (!displayName && !photoURL)
+            return;
+        if (displayName)
+            await updateProfile(this._user, { displayName });
+        if (photoURL)
+            await updateProfile(this._user, { photoURL });
+    }
+    async updateUserData(data) {
+        if (!this._user?.uid)
+            throw new Error("No authenticated user");
+        const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
+        const updateData = { ...data, updatedAt: new Date() };
+        await updateDoc(docRef, updateData);
+        await this.loadUserData();
+    }
+    async saveUserData(data) {
+        if (!this._user?.uid)
+            throw new Error("No authenticated user");
+        const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
+        const saveData = {
+            ...data,
+            createdAt: data.createdAt || new Date(),
+            updatedAt: new Date(),
+        };
+        await setDoc(docRef, saveData);
+        await this.loadUserData();
+    }
+    hasRequiredClaims(requiredClaims) {
+        return requiredClaims.every((claim) => this._claims[claim]);
+    }
+    isAdmin() {
+        return Boolean(this._claims.admin);
+    }
+    isPremium() {
+        return Boolean(this._claims.premium);
+    }
+    shouldThrottleValidation() {
+        const now = Date.now();
+        if (now - this._lastValidationTime < this.VALIDATION_THROTTLE) {
+            return true;
+        }
+        this._lastValidationTime = now;
+        return false;
+    }
+    async handleRedirect(redirectTo, params) {
+        const url = new URL(redirectTo, window.location.origin);
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                url.searchParams.append(key, value);
+            });
+        }
+        await goto(url.toString());
+    }
+    async validateClaims(requiredClaims, userClaims) {
+        if (!requiredClaims.length)
+            return true;
+        if (!userClaims)
+            return false;
+        return requiredClaims.every((claim) => userClaims[claim]);
+    }
+    async validateAuth({ authRequired = true, redirectTo = "/login", requiredClaims = [], requiredData, allowIf, redirectParams, } = {}) {
+        if (!browser)
+            return true;
+        if (this.shouldThrottleValidation())
+            return true;
+        try {
+            this._loading = true;
+            this._error = null;
+            await this.waitForInit();
+            const isAuthenticated = this.isLoggedIn;
+            if (authRequired && !isAuthenticated) {
+                await this.handleRedirect(redirectTo, {
+                    ...redirectParams,
+                    returnTo: window.location.pathname,
+                });
+                return false;
+            }
+            if (allowIf && !allowIf(this)) {
+                await this.handleRedirect(redirectTo, redirectParams);
+                return false;
+            }
+            if (requiredClaims.length > 0) {
+                const userClaims = await firekitAuthManager.user?.getIdTokenResult();
+                const hasClaims = await this.validateClaims(requiredClaims, userClaims?.claims);
+                if (!hasClaims) {
+                    await this.handleRedirect(redirectTo, redirectParams);
+                    return false;
+                }
+            }
+            if (requiredData && !requiredData(this._userData)) {
+                await this.handleRedirect(redirectTo, redirectParams);
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            this._error = error instanceof Error ? error : new Error(String(error));
+            return false;
+        }
+        finally {
+            this._loading = false;
+        }
+    }
+    async requireAuth(redirectTo = "/login", redirectParams) {
+        return this.validateAuth({
+            authRequired: true,
+            redirectTo,
+            redirectParams,
+        });
+    }
+    async requireNoAuth(redirectTo = "/dashboard", redirectParams) {
+        return this.validateAuth({
+            authRequired: false,
+            redirectTo,
+            redirectParams,
+        });
+    }
+    async requireClaims(claims, redirectTo = "/login", redirectParams) {
+        return this.validateAuth({
+            requiredClaims: claims,
+            redirectTo,
+            redirectParams,
+        });
+    }
+    async requireData(validator, redirectTo = "/login", redirectParams) {
+        return this.validateAuth({
+            requiredData: validator,
+            redirectTo,
+            redirectParams,
+        });
+    }
+    get loading() {
+        return this._loading;
+    }
+    get error() {
+        return this._error;
+    }
+}
+export const firekitAuthManager = FirekitAuthManager.getInstance();

package/dist/firebase/auth/auth.js

@@ -40,8 +40,8 @@ class FirekitAuth {
             photoURL: user.photoURL,
             isAnonymous: user.isAnonymous,
             providerId: user.providerId,
-            phoneNumber: user.phoneNumber,
-            providerData: user.providerData
+            // phoneNumber: user.phoneNumber,
+            providerData: user.providerData,
         };
         await setDoc(ref, userData, { merge: true });
     }

package/dist/firebase/auth/user.svelte.d.ts

@@ -1,50 +1 @@
-import { type User } from "firebase/auth";
-import { type DocumentData } from 'firebase/firestore';
-interface UserClaims {
-    [key: string]: any;
-    admin?: boolean;
-    premium?: boolean;
-}
-interface UserData extends DocumentData {
-    displayName?: string;
-    email?: string;
-    photoURL?: string;
-    createdAt?: Date;
-    updatedAt?: Date;
-    isProfileComplete?: boolean;
-    role?: string;
-    settings?: Record<string, any>;
-    [key: string]: any;
-}
-export declare class FirekitUser {
-    private static instance;
-    private _user;
-    private _userData;
-    private _claims;
-    readonly isLoggedIn: boolean;
-    readonly uid: string | undefined;
-    readonly email: string | null | undefined;
-    readonly displayName: string | null | undefined;
-    readonly photoURL: string | null | undefined;
-    readonly emailVerified: boolean | undefined;
-    readonly claims: UserClaims;
-    readonly data: UserData | null;
-    constructor();
-    static getInstance(): FirekitUser;
-    private loadUserData;
-    private loadUserClaims;
-    get user(): User | null | undefined;
-    updateEmail(email: string): Promise<void>;
-    updatePassword(password: string): Promise<void>;
-    updateProfile({ displayName, photoURL }: {
-        displayName?: string;
-        photoURL?: string;
-    }): Promise<void>;
-    updateUserData(data: Partial<UserData>): Promise<void>;
-    saveUserData(data: UserData): Promise<void>;
-    hasRequiredClaims(requiredClaims: string[]): boolean;
-    isAdmin(): boolean;
-    isPremium(): boolean;
-}
-export declare const firekitUser: FirekitUser;
 export {};

package/dist/firebase/auth/user.svelte.js

@@ -1,115 +1,177 @@
-import { firebaseService } from '../firebase.js';
-import { onAuthStateChanged, updateCurrentUser, updateEmail, updatePassword } from "firebase/auth";
-import { doc, getDoc, setDoc, updateDoc } from 'firebase/firestore';
-export class FirekitUser {
-    static instance;
-    _user = $state();
-    _userData = $state(null);
-    _claims = $state({});
-    isLoggedIn = $derived(Boolean(this._user));
-    uid = $derived(this._user?.uid);
-    email = $derived(this._user?.email);
-    displayName = $derived(this._user?.displayName);
-    photoURL = $derived(this._user?.photoURL);
-    emailVerified = $derived(this._user?.emailVerified);
-    claims = $derived(this._claims);
-    data = $derived(this._userData);
-    constructor() {
-        onAuthStateChanged(firebaseService.getAuthInstance(), async (user) => {
-            this._user = user;
-            if (user) {
-                await Promise.all([
-                    this.loadUserData(),
-                    this.loadUserClaims()
-                ]);
-            }
-            else {
-                this._userData = null;
-                this._claims = {};
-            }
-        });
-    }
-    static getInstance() {
-        if (!FirekitUser.instance) {
-            FirekitUser.instance = new FirekitUser();
-        }
-        return FirekitUser.instance;
-    }
-    async loadUserData() {
-        if (!this._user?.uid)
-            return;
-        const docRef = doc(firebaseService.getDb(), 'users', this._user.uid);
-        const docSnap = await getDoc(docRef);
-        if (docSnap.exists()) {
-            this._userData = docSnap.data();
-        }
-        else {
-            // Initialize user document if it doesn't exist
-            const initialData = {
-                displayName: this._user.displayName || '',
-                email: this._user.email || '',
-                photoURL: this._user.photoURL || '',
-                createdAt: new Date(),
-                updatedAt: new Date(),
-                isProfileComplete: false
-            };
-            await this.saveUserData(initialData);
-        }
-    }
-    async loadUserClaims() {
-        if (!this._user)
-            return;
-        const tokenResult = await this._user.getIdTokenResult();
-        this._claims = tokenResult.claims;
-    }
-    get user() {
-        return this._user;
-    }
-    async updateEmail(email) {
-        if (!this._user)
-            throw new Error('No authenticated user');
-        await updateEmail(this._user, email);
-    }
-    async updatePassword(password) {
-        if (!this._user)
-            throw new Error('No authenticated user');
-        await updatePassword(this._user, password);
-    }
-    async updateProfile({ displayName, photoURL }) {
-        if (!this._user)
-            throw new Error('No authenticated user');
-    }
-    async updateUserData(data) {
-        if (!this._user?.uid)
-            throw new Error('No authenticated user');
-        const docRef = doc(firebaseService.getDb(), 'users', this._user.uid);
-        const updateData = {
-            ...data,
-            updatedAt: new Date()
-        };
-        await updateDoc(docRef, updateData);
-        await this.loadUserData(); // Reload user data
-    }
-    async saveUserData(data) {
-        if (!this._user?.uid)
-            throw new Error('No authenticated user');
-        const docRef = doc(firebaseService.getDb(), 'users', this._user.uid);
-        const saveData = {
-            ...data,
-            createdAt: data.createdAt || new Date(),
-            updatedAt: new Date()
-        };
-        await setDoc(docRef, saveData);
-        await this.loadUserData(); // Reload user data
-    }
-    hasRequiredClaims(requiredClaims) {
-        return requiredClaims.every(claim => this._claims[claim]);
-    }
-    isAdmin() {
-        return Boolean(this._claims.admin);
-    }
-    isPremium() {
-        return Boolean(this._claims.premium);
-    }
-}
-export const firekitUser = new FirekitUser();
+"use strict";
+// import { browser } from "$app/environment";
+// import { firebaseService } from "../firebase.js";
+// import {
+//   onAuthStateChanged,
+//   updateCurrentUser,
+//   updateEmail,
+//   updatePassword,
+//   updatePhoneNumber,
+//   updateProfile,
+//   type User,
+// } from "firebase/auth";
+// import {
+//   doc,
+//   getDoc,
+//   setDoc,
+//   updateDoc,
+//   type DocumentData,
+// } from "firebase/firestore";
+// import { toast } from "svelte-sonner";
+// import { firekitAuth } from "./auth.js";
+// interface UserClaims {
+//   [key: string]: any;
+//   admin?: boolean;
+//   premium?: boolean;
+// }
+// interface UserData extends DocumentData {
+//   displayName?: string;
+//   email?: string;
+//   photoURL?: string;
+//   createdAt?: Date;
+//   updatedAt?: Date;
+//   isProfileComplete?: boolean;
+//   role?: string;
+//   settings?: Record<string, any>;
+//   [key: string]: any;
+// }
+// export class FirekitUser {
+//   private static instance: FirekitUser;
+//   private _user: User | null | undefined = $state();
+//   private _userData: UserData | null = $state(null);
+//   private _claims: UserClaims = $state({});
+//   private _initialized = $state(false);
+//   readonly isLoggedIn = $derived(Boolean(this._user));
+//   readonly uid = $derived(this._user?.uid);
+//   readonly email = $derived(this._user?.email);
+//   readonly displayName = $derived(this._user?.displayName);
+//   readonly photoURL = $derived(this._user?.photoURL);
+//   readonly emailVerified = $derived(this._user?.emailVerified);
+//   readonly claims = $derived(this._claims);
+//   readonly data = $derived(this._userData);
+//   readonly initialized = $derived(this._initialized);
+//   private _initPromise: Promise<void> | null = null;
+//   constructor() {
+//     if (browser) {
+//       // Add this check
+//       this.initialize();
+//     }
+//   }
+//   private async initialize(): Promise<void> {
+//     if (this._initialized) return;
+//     return new Promise((resolve) => {
+//       onAuthStateChanged(firebaseService.getAuthInstance(), async (user) => {
+//         this._user = user;
+//         if (user) {
+//           await Promise.all([this.loadUserData(), this.loadUserClaims()]);
+//         } else {
+//           this._userData = null;
+//           this._claims = {};
+//         }
+//         this._initialized = true;
+//         resolve();
+//       });
+//     });
+//   }
+//   async waitForInit(): Promise<void> {
+//     if (this._initialized) return;
+//     return this._initPromise || Promise.resolve();
+//   }
+//   static getInstance(): FirekitUser {
+//     if (!FirekitUser.instance) {
+//       FirekitUser.instance = new FirekitUser();
+//     }
+//     return FirekitUser.instance;
+//   }
+//   private async loadUserData() {
+//     if (!this._user?.uid) return;
+//     const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
+//     const docSnap = await getDoc(docRef);
+//     if (docSnap.exists()) {
+//       this._userData = docSnap.data() as UserData;
+//     } else {
+//       // Initialize user document if it doesn't exist
+//       const initialData: UserData = {
+//         displayName: this._user.displayName || "",
+//         email: this._user.email || "",
+//         photoURL: this._user.photoURL || "",
+//         createdAt: new Date(),
+//         updatedAt: new Date(),
+//         isProfileComplete: false,
+//       };
+//       await this.saveUserData(initialData);
+//     }
+//   }
+//   private async loadUserClaims() {
+//     if (!this._user) return;
+//     const tokenResult = await this._user.getIdTokenResult();
+//     this._claims = tokenResult.claims as UserClaims;
+//   }
+//   get user(): User | null | undefined {
+//     return this._user;
+//   }
+//   async updateEmailUser(email: string) {
+//     let message: string = "";
+//     if (!this._user) throw new Error("No authenticated user");
+//     try {
+//       await updateEmail(this._user, email);
+//       await this.updateUserData({ email });
+//       toast.success("Email updated successfully!", {
+//         description:
+//           "Please note that you will be logged out, and you will need to log in again using your new email address.",
+//       });
+//       setTimeout(async () => {
+//         await firekitAuth.logOut();
+//       }, 4500);
+//     } catch (error) {
+//       toast.error(error.message);
+//     }
+//   }
+//   async updatePassword(password: string) {
+//     if (!this._user) throw new Error("No authenticated user");
+//     await updatePassword(this._user, password);
+//   }
+//   async updateProfileInfo({
+//     displayName,
+//     photoURL,
+//   }: {
+//     displayName?: string;
+//     photoURL?: string;
+//   }) {
+//     if (!this._user) throw new Error("No authenticated user");
+//     if (!displayName && !photoURL) return;
+//     if (displayName) await updateProfile(this._user, { displayName });
+//     if (photoURL) await updateProfile(this._user, { photoURL });
+//   }
+//   async updateUserData(data: Partial<UserData>) {
+//     if (!this._user?.uid) throw new Error("No authenticated user");
+//     const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
+//     const updateData = {
+//       ...data,
+//       updatedAt: new Date(),
+//     };
+//     await updateDoc(docRef, updateData);
+//     await this.loadUserData(); // Reload user data
+//   }
+//   async saveUserData(data: UserData) {
+//     if (!this._user?.uid) throw new Error("No authenticated user");
+//     const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
+//     const saveData = {
+//       ...data,
+//       createdAt: data.createdAt || new Date(),
+//       updatedAt: new Date(),
+//     };
+//     await setDoc(docRef, saveData);
+//     await this.loadUserData(); // Reload user data
+//   }
+//   hasRequiredClaims(requiredClaims: string[]): boolean {
+//     return requiredClaims.every((claim) => this._claims[claim]);
+//   }
+//   isAdmin(): boolean {
+//     return Boolean(this._claims.admin);
+//   }
+//   isPremium(): boolean {
+//     return Boolean(this._claims.premium);
+//   }
+// }
+// export const firekitUser = FirekitUser.getInstance();

package/dist/firebase/firestore/document-mutations.svelte.js

@@ -1,6 +1,6 @@
-import { addDoc, setDoc, updateDoc, deleteDoc, doc, getDoc, collection, serverTimestamp } from "firebase/firestore";
+import { addDoc, setDoc, updateDoc, deleteDoc, doc, getDoc, collection, serverTimestamp, } from "firebase/firestore";
 import { firebaseService } from "../firebase.js";
-import { firekitUser } from "../auth/user.svelte.js";
+import { firekitAuthManager } from "../auth/auth-manager.svelte.js";
 class FirekitDocumentMutations {
     constructor() { }
     async add(collectionPath, data, options = { timestamps: true }) {
@@ -10,24 +10,27 @@ class FirekitDocumentMutations {
             ...data,
             ...(options.timestamps && {
                 createdAt: serverTimestamp(),
-                createdBy: firekitUser.uid,
+                createdBy: firekitAuthManager.uid,
                 updatedAt: serverTimestamp(),
-                updatedBy: firekitUser.uid
-            })
+                updatedBy: firekitAuthManager.uid,
+            }),
         };
         return addDoc(colRef, dataToAdd);
     }
-    async set(path, data, options = { merge: false, timestamps: true }) {
+    async set(path, data, options = {
+        merge: false,
+        timestamps: true,
+    }) {
         const firestore = firebaseService.getDb();
         const docRef = doc(firestore, path);
         const dataToSet = {
             ...data,
             ...(options.timestamps && {
                 createdAt: serverTimestamp(),
-                createdBy: firekitUser.uid,
+                createdBy: firekitAuthManager.uid,
                 updatedAt: serverTimestamp(),
-                updatedBy: firekitUser.uid
-            })
+                updatedBy: firekitAuthManager.uid,
+            }),
         };
         return setDoc(docRef, dataToSet, { merge: options.merge });
     }
@@ -38,8 +41,8 @@ class FirekitDocumentMutations {
             ...data,
             ...(options.timestamps && {
                 updatedAt: serverTimestamp(),
-                updatedBy: firekitUser.uid
-            })
+                updatedBy: firekitAuthManager.uid,
+            }),
         };
         return updateDoc(docRef, dataToUpdate);
     }