@umituz/react-native-firebase 1.13.35 → 1.13.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.35",
+  "version": "1.13.37",
   "description": "Unified Firebase package for React Native apps - Auth and Firestore services using Firebase JS SDK (no native modules).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -49,16 +49,25 @@
     "expo-apple-authentication": "^8.0.8",
     "expo-crypto": "^15.0.8",
     "firebase": "^12.6.0",
+    "firebase-admin": "^13.0.2",
     "react": "19.1.0",
     "react-native": "0.81.5",
     "typescript": "~5.9.2"
   },
+  "optionalDependencies": {
+    "firebase-admin": "^13.0.2"
+  },
   "publishConfig": {
     "access": "public"
   },
   "files": [
     "src",
+    "scripts",
     "README.md",
     "LICENSE"
-  ]
+  ],
+  "exports": {
+    ".": "./src/index.ts",
+    "./scripts": "./scripts/index.ts"
+  }
 }

package/scripts/auth.ts

@@ -0,0 +1,142 @@
+/**
+ * Firebase Admin Auth Utilities
+ * Generic auth operations for admin scripts
+ */
+
+import * as admin from "firebase-admin";
+import type { UserInfo, CleanupResult } from "./types";
+
+/**
+ * List all users from Firebase Auth
+ */
+export async function listAllUsers(auth: admin.auth.Auth): Promise<UserInfo[]> {
+  const users: UserInfo[] = [];
+  let nextPageToken: string | undefined;
+
+  do {
+    const result = await auth.listUsers(1000, nextPageToken);
+
+    result.users.forEach((user) => {
+      users.push({
+        uid: user.uid,
+        email: user.email,
+        displayName: user.displayName,
+        isAnonymous: !user.providerData || user.providerData.length === 0,
+        createdAt: user.metadata.creationTime
+          ? new Date(user.metadata.creationTime)
+          : undefined,
+        providerCount: user.providerData?.length ?? 0,
+      });
+    });
+
+    nextPageToken = result.pageToken;
+  } while (nextPageToken);
+
+  return users;
+}
+
+/**
+ * List only authenticated users (with email/providers)
+ */
+export async function listAuthenticatedUsers(
+  auth: admin.auth.Auth
+): Promise<UserInfo[]> {
+  const allUsers = await listAllUsers(auth);
+  return allUsers.filter((user) => !user.isAnonymous && user.email);
+}
+
+/**
+ * List only anonymous users
+ */
+export async function listAnonymousUsers(
+  auth: admin.auth.Auth
+): Promise<UserInfo[]> {
+  const allUsers = await listAllUsers(auth);
+  return allUsers.filter((user) => user.isAnonymous);
+}
+
+/**
+ * Delete users by UIDs
+ */
+export async function deleteUsers(
+  auth: admin.auth.Auth,
+  uids: string[],
+  onProgress?: (deleted: number, total: number) => void
+): Promise<CleanupResult> {
+  const result: CleanupResult = {
+    totalProcessed: uids.length,
+    deleted: 0,
+    preserved: 0,
+    errors: [],
+  };
+
+  for (const uid of uids) {
+    try {
+      await auth.deleteUser(uid);
+      result.deleted++;
+      onProgress?.(result.deleted, uids.length);
+    } catch (error) {
+      result.errors.push(`Failed to delete ${uid}: ${error}`);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Cleanup anonymous users - delete all users without providers
+ */
+export async function cleanupAnonymousUsers(
+  auth: admin.auth.Auth,
+  onProgress?: (deleted: number, total: number) => void
+): Promise<CleanupResult> {
+  const anonymousUsers = await listAnonymousUsers(auth);
+  const uids = anonymousUsers.map((u) => u.uid);
+
+  if (uids.length === 0) {
+    return {
+      totalProcessed: 0,
+      deleted: 0,
+      preserved: 0,
+      errors: [],
+    };
+  }
+
+  const deleteResult = await deleteUsers(auth, uids, onProgress);
+
+  // Count preserved (authenticated) users
+  const authenticatedUsers = await listAuthenticatedUsers(auth);
+  deleteResult.preserved = authenticatedUsers.length;
+
+  return deleteResult;
+}
+
+/**
+ * Delete all users from Firebase Auth
+ */
+export async function deleteAllUsers(
+  auth: admin.auth.Auth,
+  onProgress?: (deleted: number, total: number) => void
+): Promise<CleanupResult> {
+  const allUsers = await listAllUsers(auth);
+  const uids = allUsers.map((u) => u.uid);
+  return deleteUsers(auth, uids, onProgress);
+}
+
+/**
+ * Get user statistics
+ */
+export async function getUserStats(auth: admin.auth.Auth): Promise<{
+  total: number;
+  anonymous: number;
+  authenticated: number;
+}> {
+  const allUsers = await listAllUsers(auth);
+  const anonymous = allUsers.filter((u) => u.isAnonymous).length;
+
+  return {
+    total: allUsers.length,
+    anonymous,
+    authenticated: allUsers.length - anonymous,
+  };
+}

package/scripts/firestore.ts

@@ -0,0 +1,280 @@
+/**
+ * Firebase Admin Firestore Utilities
+ * Generic Firestore operations for admin scripts
+ */
+
+import * as admin from "firebase-admin";
+import type { CollectionInfo, BatchResult } from "./types";
+
+const BATCH_SIZE = 500;
+
+/**
+ * List all root-level collections
+ */
+export async function listCollections(
+  db: admin.firestore.Firestore
+): Promise<CollectionInfo[]> {
+  const collections = await db.listCollections();
+  const result: CollectionInfo[] = [];
+
+  for (const collection of collections) {
+    const snapshot = await collection.limit(1000).get();
+    const info: CollectionInfo = {
+      name: collection.id,
+      documentCount: snapshot.docs.length,
+      sampleDocumentId: snapshot.docs[0]?.id,
+    };
+
+    if (!snapshot.empty) {
+      const subcollections = await snapshot.docs[0].ref.listCollections();
+      info.hasSubcollections = subcollections.length > 0;
+    }
+
+    result.push(info);
+  }
+
+  return result.sort((a, b) => b.documentCount - a.documentCount);
+}
+
+/**
+ * List subcollections for a user document
+ */
+export async function listUserSubcollections(
+  db: admin.firestore.Firestore,
+  userId: string
+): Promise<CollectionInfo[]> {
+  const userRef = db.collection("users").doc(userId);
+  const subcollections = await userRef.listCollections();
+  const result: CollectionInfo[] = [];
+
+  for (const subcollection of subcollections) {
+    const count = await subcollection.count().get();
+    result.push({
+      name: subcollection.id,
+      documentCount: count.data().count,
+    });
+  }
+
+  return result;
+}
+
+/**
+ * Delete collection in batches
+ */
+export async function deleteCollection(
+  db: admin.firestore.Firestore,
+  collectionPath: string,
+  onProgress?: (deleted: number) => void
+): Promise<number> {
+  let totalDeleted = 0;
+  let hasMore = true;
+
+  while (hasMore) {
+    const snapshot = await db
+      .collection(collectionPath)
+      .orderBy("__name__")
+      .limit(BATCH_SIZE)
+      .get();
+
+    if (snapshot.empty) {
+      hasMore = false;
+      continue;
+    }
+
+    const batch = db.batch();
+    snapshot.docs.forEach((doc) => batch.delete(doc.ref));
+    await batch.commit();
+
+    totalDeleted += snapshot.docs.length;
+    onProgress?.(totalDeleted);
+  }
+
+  return totalDeleted;
+}
+
+/**
+ * Delete user subcollection for all users
+ */
+export async function deleteUserSubcollection(
+  db: admin.firestore.Firestore,
+  subcollectionName: string,
+  onProgress?: (deleted: number) => void
+): Promise<number> {
+  let totalDeleted = 0;
+  const usersSnapshot = await db.collection("users").get();
+
+  for (const userDoc of usersSnapshot.docs) {
+    const subcollectionRef = userDoc.ref.collection(subcollectionName);
+    const subcollectionSnapshot = await subcollectionRef.get();
+
+    if (!subcollectionSnapshot.empty) {
+      const batch = db.batch();
+      subcollectionSnapshot.docs.forEach((doc) => batch.delete(doc.ref));
+      await batch.commit();
+      totalDeleted += subcollectionSnapshot.docs.length;
+      onProgress?.(totalDeleted);
+    }
+  }
+
+  return totalDeleted;
+}
+
+/**
+ * Delete all Firestore data
+ */
+export async function deleteAllData(
+  db: admin.firestore.Firestore,
+  onProgress?: (collection: string, deleted: number) => void
+): Promise<number> {
+  let totalDeleted = 0;
+  const collections = await db.listCollections();
+
+  for (const collection of collections) {
+    const snapshot = await collection.get();
+
+    // Delete subcollections first for users collection
+    if (collection.id === "users") {
+      for (const doc of snapshot.docs) {
+        const subcollections = await doc.ref.listCollections();
+        for (const subcollection of subcollections) {
+          const subSnapshot = await subcollection.get();
+          if (!subSnapshot.empty) {
+            const batch = db.batch();
+            subSnapshot.docs.forEach((subDoc) => batch.delete(subDoc.ref));
+            await batch.commit();
+            totalDeleted += subSnapshot.docs.length;
+          }
+        }
+      }
+    }
+
+    // Delete main collection documents
+    if (!snapshot.empty) {
+      const batch = db.batch();
+      snapshot.docs.forEach((doc) => batch.delete(doc.ref));
+      await batch.commit();
+      totalDeleted += snapshot.docs.length;
+      onProgress?.(collection.id, totalDeleted);
+    }
+  }
+
+  return totalDeleted;
+}
+
+/**
+ * Seed documents in batches
+ */
+export async function seedBatch(
+  db: admin.firestore.Firestore,
+  collectionPath: string,
+  docs: Array<{ id: string; data: Record<string, unknown> }>
+): Promise<BatchResult> {
+  const result: BatchResult = {
+    success: true,
+    processed: 0,
+    errors: [],
+  };
+
+  for (let i = 0; i < docs.length; i += BATCH_SIZE) {
+    const batch = db.batch();
+    const slice = docs.slice(i, i + BATCH_SIZE);
+
+    for (const { id, data } of slice) {
+      const ref = db.collection(collectionPath).doc(id);
+      const clean = Object.fromEntries(
+        Object.entries(data).filter(([, v]) => v !== undefined)
+      );
+      batch.set(ref, clean);
+    }
+
+    try {
+      await batch.commit();
+      result.processed += slice.length;
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Batch failed at index ${i}: ${error}`);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Seed user subcollection
+ */
+export async function seedUserSubcollection(
+  db: admin.firestore.Firestore,
+  userId: string,
+  subcollectionName: string,
+  docs: Array<{ id: string; data: Record<string, unknown> }>
+): Promise<BatchResult> {
+  const result: BatchResult = {
+    success: true,
+    processed: 0,
+    errors: [],
+  };
+
+  const batch = db.batch();
+
+  for (const { id, data } of docs) {
+    const ref = db
+      .collection("users")
+      .doc(userId)
+      .collection(subcollectionName)
+      .doc(id);
+    const clean = Object.fromEntries(
+      Object.entries(data).filter(([, v]) => v !== undefined)
+    );
+    batch.set(ref, clean);
+  }
+
+  try {
+    await batch.commit();
+    result.processed = docs.length;
+  } catch (error) {
+    result.success = false;
+    result.errors.push(`Failed to seed subcollection: ${error}`);
+  }
+
+  return result;
+}
+
+/**
+ * Count documents in collection
+ */
+export async function countDocuments(
+  db: admin.firestore.Firestore,
+  collectionPath: string
+): Promise<number> {
+  const count = await db.collection(collectionPath).count().get();
+  return count.data().count;
+}
+
+/**
+ * Get user document count statistics
+ */
+export async function getUserStats(db: admin.firestore.Firestore): Promise<{
+  total: number;
+  anonymous: number;
+  authenticated: number;
+}> {
+  const usersSnapshot = await db.collection("users").get();
+
+  let anonymous = 0;
+  let authenticated = 0;
+
+  usersSnapshot.docs.forEach((doc) => {
+    const data = doc.data();
+    if (data.isAnonymous) {
+      anonymous++;
+    } else {
+      authenticated++;
+    }
+  });
+
+  return {
+    total: usersSnapshot.docs.length,
+    anonymous,
+    authenticated,
+  };
+}

package/scripts/index.ts

@@ -0,0 +1,85 @@
+/**
+ * Firebase Admin Scripts
+ *
+ * Generic utilities for Firebase Admin operations.
+ * Use these for CLI scripts, seeding, cleanup, and testing.
+ *
+ * Usage:
+ *   import { initFirebaseAdmin, cleanupAnonymousUsers } from "@umituz/react-native-firebase/scripts";
+ *
+ *   const app = initFirebaseAdmin({
+ *     serviceAccountPath: "./service-account.json",
+ *     projectId: "my-project",
+ *     storageBucket: "my-project.appspot.com",
+ *   });
+ *
+ *   const auth = getAuthAdmin(app);
+ *   await cleanupAnonymousUsers(auth);
+ */
+
+// Types
+export type {
+  FirebaseAdminConfig,
+  CollectionInfo,
+  UserInfo,
+  CleanupResult,
+  BatchResult,
+  StorageFileInfo,
+  ResetSummary,
+} from "./types";
+
+// Initialization
+export {
+  initFirebaseAdmin,
+  getFirestoreAdmin,
+  getAuthAdmin,
+  getStorageAdmin,
+  resetFirebaseAdmin,
+} from "./init";
+
+// Auth utilities
+export {
+  listAllUsers,
+  listAuthenticatedUsers,
+  listAnonymousUsers,
+  deleteUsers,
+  cleanupAnonymousUsers,
+  deleteAllUsers,
+  getUserStats as getAuthUserStats,
+} from "./auth";
+
+// Firestore utilities
+export {
+  listCollections,
+  listUserSubcollections,
+  deleteCollection,
+  deleteUserSubcollection,
+  deleteAllData,
+  seedBatch,
+  seedUserSubcollection,
+  countDocuments,
+  getUserStats as getFirestoreUserStats,
+} from "./firestore";
+
+// Storage utilities
+export {
+  listFiles,
+  deleteAllFiles,
+  deleteFilesByPrefix,
+  getStorageStats,
+  deleteUserFiles,
+} from "./storage";
+
+// Utility functions
+export {
+  randomId,
+  randomDate,
+  randomItem,
+  randomNumber,
+  randomBoolean,
+  sleep,
+  formatBytes,
+  createConfirmationTimer,
+  printSeparator,
+  printHeader,
+} from "./utils";

package/scripts/init.ts

@@ -0,0 +1,61 @@
+/**
+ * Firebase Admin Initialization
+ * Dynamic configuration - no hardcoded values
+ */
+
+import * as admin from "firebase-admin";
+import type { FirebaseAdminConfig } from "./types";
+
+let initializedApp: admin.app.App | null = null;
+
+/**
+ * Initialize Firebase Admin SDK with config
+ * @param config - Firebase Admin configuration
+ * @returns Initialized Firebase Admin app
+ */
+export function initFirebaseAdmin(config: FirebaseAdminConfig): admin.app.App {
+  if (initializedApp) {
+    return initializedApp;
+  }
+
+  if (admin.apps.length > 0) {
+    initializedApp = admin.apps[0]!;
+    return initializedApp;
+  }
+
+  initializedApp = admin.initializeApp({
+    credential: admin.credential.cert(config.serviceAccountPath),
+    projectId: config.projectId,
+    storageBucket: config.storageBucket,
+  });
+
+  return initializedApp;
+}
+
+/**
+ * Get Firestore instance
+ */
+export function getFirestoreAdmin(app: admin.app.App): admin.firestore.Firestore {
+  return admin.firestore(app);
+}
+
+/**
+ * Get Auth instance
+ */
+export function getAuthAdmin(app: admin.app.App): admin.auth.Auth {
+  return admin.auth(app);
+}
+
+/**
+ * Get Storage bucket
+ */
+export function getStorageAdmin(app: admin.app.App): admin.storage.Storage {
+  return admin.storage(app);
+}
+
+/**
+ * Reset initialized app (for testing)
+ */
+export function resetFirebaseAdmin(): void {
+  initializedApp = null;
+}

package/scripts/storage.ts

@@ -0,0 +1,119 @@
+/**
+ * Firebase Admin Storage Utilities
+ * Generic Storage operations for admin scripts
+ */
+
+import * as admin from "firebase-admin";
+import type { StorageFileInfo, CleanupResult } from "./types";
+
+/**
+ * List all files in storage bucket
+ */
+export async function listFiles(
+  storage: admin.storage.Storage,
+  prefix?: string
+): Promise<StorageFileInfo[]> {
+  const bucket = storage.bucket();
+  const [files] = await bucket.getFiles({ prefix });
+
+  return files.map((file) => ({
+    name: file.name,
+    size: parseInt(file.metadata.size as string, 10) || 0,
+    contentType: file.metadata.contentType,
+    createdAt: file.metadata.timeCreated
+      ? new Date(file.metadata.timeCreated)
+      : undefined,
+  }));
+}
+
+/**
+ * Delete all files in storage
+ */
+export async function deleteAllFiles(
+  storage: admin.storage.Storage,
+  onProgress?: (deleted: number, total: number) => void
+): Promise<CleanupResult> {
+  const bucket = storage.bucket();
+  const [files] = await bucket.getFiles();
+
+  const result: CleanupResult = {
+    totalProcessed: files.length,
+    deleted: 0,
+    preserved: 0,
+    errors: [],
+  };
+
+  for (const file of files) {
+    try {
+      await file.delete();
+      result.deleted++;
+      onProgress?.(result.deleted, files.length);
+    } catch (error) {
+      result.errors.push(`Failed to delete ${file.name}: ${error}`);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Delete files by prefix (folder)
+ */
+export async function deleteFilesByPrefix(
+  storage: admin.storage.Storage,
+  prefix: string,
+  onProgress?: (deleted: number, total: number) => void
+): Promise<CleanupResult> {
+  const bucket = storage.bucket();
+  const [files] = await bucket.getFiles({ prefix });
+
+  const result: CleanupResult = {
+    totalProcessed: files.length,
+    deleted: 0,
+    preserved: 0,
+    errors: [],
+  };
+
+  for (const file of files) {
+    try {
+      await file.delete();
+      result.deleted++;
+      onProgress?.(result.deleted, files.length);
+    } catch (error) {
+      result.errors.push(`Failed to delete ${file.name}: ${error}`);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Get storage statistics
+ */
+export async function getStorageStats(
+  storage: admin.storage.Storage
+): Promise<{
+  totalFiles: number;
+  totalSizeBytes: number;
+  totalSizeMB: number;
+}> {
+  const files = await listFiles(storage);
+  const totalSizeBytes = files.reduce((sum, file) => sum + file.size, 0);
+
+  return {
+    totalFiles: files.length,
+    totalSizeBytes,
+    totalSizeMB: Math.round((totalSizeBytes / (1024 * 1024)) * 100) / 100,
+  };
+}
+
+/**
+ * Delete user files (files in users/{userId}/ folder)
+ */
+export async function deleteUserFiles(
+  storage: admin.storage.Storage,
+  userId: string,
+  onProgress?: (deleted: number, total: number) => void
+): Promise<CleanupResult> {
+  return deleteFilesByPrefix(storage, `users/${userId}/`, onProgress);
+}

package/scripts/types.ts

@@ -0,0 +1,55 @@
+/**
+ * Firebase Admin Scripts - Shared Types
+ * Generic types for Firebase Admin operations
+ */
+
+export interface FirebaseAdminConfig {
+  /** Path to service account JSON file */
+  serviceAccountPath: string;
+  /** Firebase project ID */
+  projectId: string;
+  /** Storage bucket name (optional) */
+  storageBucket?: string;
+}
+
+export interface CollectionInfo {
+  name: string;
+  documentCount: number;
+  sampleDocumentId?: string;
+  hasSubcollections?: boolean;
+}
+
+export interface UserInfo {
+  uid: string;
+  email?: string;
+  displayName?: string;
+  isAnonymous: boolean;
+  createdAt?: Date;
+  providerCount: number;
+}
+
+export interface CleanupResult {
+  totalProcessed: number;
+  deleted: number;
+  preserved: number;
+  errors: string[];
+}
+
+export interface BatchResult {
+  success: boolean;
+  processed: number;
+  errors: string[];
+}
+
+export interface StorageFileInfo {
+  name: string;
+  size: number;
+  contentType?: string;
+  createdAt?: Date;
+}
+
+export interface ResetSummary {
+  authUsersDeleted: number;
+  firestoreDocsDeleted: number;
+  storageFilesDeleted: number;
+}

package/scripts/utils.ts

@@ -0,0 +1,95 @@
+/**
+ * Firebase Admin Scripts - Utility Functions
+ * Generic helpers for seeding and testing
+ */
+
+/**
+ * Generate random ID
+ */
+export function randomId(): string {
+  return (
+    Math.random().toString(36).substring(2, 15) +
+    Math.random().toString(36).substring(2, 15)
+  );
+}
+
+/**
+ * Generate random date within the past N days
+ */
+export function randomDate(daysAgo: number): Date {
+  const now = new Date();
+  const pastDate = new Date(now.getTime() - daysAgo * 24 * 60 * 60 * 1000);
+  const randomTime =
+    pastDate.getTime() + Math.random() * (now.getTime() - pastDate.getTime());
+  return new Date(randomTime);
+}
+
+/**
+ * Get random item from array
+ */
+export function randomItem<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+/**
+ * Generate random number in range
+ */
+export function randomNumber(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+/**
+ * Generate random boolean
+ */
+export function randomBoolean(): boolean {
+  return Math.random() > 0.5;
+}
+
+/**
+ * Sleep for specified milliseconds
+ */
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Format bytes to human readable string
+ */
+export function formatBytes(bytes: number): string {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+
+/**
+ * Create a confirmation prompt (for CLI scripts)
+ */
+export function createConfirmationTimer(
+  seconds: number,
+  warningMessage: string
+): Promise<void> {
+  return new Promise((resolve) => {
+    console.log(warningMessage);
+    console.log(`\nPress Ctrl+C to cancel, or wait ${seconds} seconds to continue...\n`);
+    setTimeout(resolve, seconds * 1000);
+  });
+}
+
+/**
+ * Print separator line
+ */
+export function printSeparator(char = "=", length = 70): void {
+  console.log(char.repeat(length));
+}
+
+/**
+ * Print header with separators
+ */
+export function printHeader(title: string): void {
+  printSeparator();
+  console.log(title);
+  printSeparator();
+  console.log();
+}

package/src/auth/infrastructure/services/firestore-utils.service.ts

@@ -44,7 +44,7 @@ export interface FirestoreQueryResult {
   readonly shouldSkip: boolean;
   readonly reason?: FirestoreQuerySkipReason;
   readonly userId: string | null;
-  readonly isGuest: boolean;
+  readonly isAnonymous: boolean;
   readonly isAuthenticated: boolean;
 }
 
@@ -70,7 +70,7 @@ export function shouldSkipFirestoreQuery(
         shouldSkip: true,
         reason: "no_auth",
         userId: null,
-        isGuest: false,
+        isAnonymous: false,
         isAuthenticated: false,
       };
     }
@@ -85,20 +85,20 @@ export function shouldSkipFirestoreQuery(
           shouldSkip: true,
           reason: "not_authenticated",
           userId: null,
-          isGuest: false,
+          isAnonymous: false,
           isAuthenticated: false,
         };
       }
     }
 
-    // Guest/anonymous user
-    if (authState.isGuest) {
+    // Anonymous user
+    if (authState.isAnonymous) {
       if (skipForGuest) {
         return {
           shouldSkip: true,
           reason: "is_guest",
           userId: authState.userId,
-          isGuest: true,
+          isAnonymous: true,
           isAuthenticated: false,
         };
       }
@@ -111,7 +111,7 @@ export function shouldSkipFirestoreQuery(
           shouldSkip: true,
           reason: "user_id_mismatch",
           userId: authState.userId,
-          isGuest: authState.isGuest,
+          isAnonymous: authState.isAnonymous,
           isAuthenticated: authState.isAuthenticated,
         };
       }
@@ -121,7 +121,7 @@ export function shouldSkipFirestoreQuery(
     return {
       shouldSkip: false,
       userId: authState.userId,
-      isGuest: authState.isGuest,
+      isAnonymous: authState.isAnonymous,
       isAuthenticated: authState.isAuthenticated,
     };
   } catch (error) {
@@ -134,7 +134,7 @@ export function shouldSkipFirestoreQuery(
       shouldSkip: true,
       reason: "invalid_options",
       userId: null,
-      isGuest: false,
+      isAnonymous: false,
       isAuthenticated: false,
     };
   }

package/src/auth/presentation/hooks/useAnonymousAuth.ts

@@ -63,7 +63,6 @@ export function useAnonymousAuth(auth: Auth | null): UseAnonymousAuthResult {
         setAuthState({
           isAuthenticated: false,
           isAnonymous: false,
-          isGuest: false,
           currentUser: null,
           userId: null,
         });
@@ -72,7 +71,6 @@ export function useAnonymousAuth(auth: Auth | null): UseAnonymousAuthResult {
         setAuthState({
           isAuthenticated: true,
           isAnonymous: anonymous,
-          isGuest: anonymous,
           currentUser: user,
           userId: user.uid,
         });
@@ -104,7 +102,6 @@ export function useAnonymousAuth(auth: Auth | null): UseAnonymousAuthResult {
       setAuthState({
         isAuthenticated: false,
         isAnonymous: false,
-        isGuest: false,
         currentUser: null,
         userId: null,
       });