@umituz/react-native-firebase 1.13.49 → 1.13.50

package/scripts/cli.ts

@@ -22,90 +22,22 @@
  */
 
 import * as path from "path";
-import * as fs from "fs";
 import {
   initFirebaseAdmin,
   getFirestoreAdmin,
   resetFirebaseAdmin,
 } from "./init";
+import { parseArgs, getProjectId } from "./cli-parser";
 import {
-  getUserData,
-  initializeUserCredits,
-  setUserCredits,
-  listUsersWithCredits,
-  getCreditsSummary,
-  printUserData,
-} from "./user";
-import { printHeader, printSeparator } from "./utils";
-
-interface CLIOptions {
-  serviceAccountPath: string;
-  projectId?: string;
-  creditsCollection: string;
-  textLimit: number;
-  imageLimit: number;
-}
-
-function parseArgs(): { command: string; args: string[]; options: CLIOptions } {
-  const args = process.argv.slice(2);
-  const command = args[0] || "help";
-  const commandArgs: string[] = [];
-  const options: CLIOptions = {
-    serviceAccountPath: "./firebase-service-account.json",
-    creditsCollection: "user_credits",
-    textLimit: 100,
-    imageLimit: 100,
-  };
-
-  let i = 1;
-  while (i < args.length) {
-    const arg = args[i];
-    if (arg.startsWith("--")) {
-      const key = arg.slice(2);
-      const value = args[++i];
-      switch (key) {
-        case "service-account":
-          options.serviceAccountPath = value;
-          break;
-        case "project-id":
-          options.projectId = value;
-          break;
-        case "credits-collection":
-          options.creditsCollection = value;
-          break;
-        case "text-limit":
-          options.textLimit = parseInt(value) || 100;
-          break;
-        case "image-limit":
-          options.imageLimit = parseInt(value) || 100;
-          break;
-      }
-    } else {
-      commandArgs.push(arg);
-    }
-    i++;
-  }
-
-  return { command, args: commandArgs, options };
-}
-
-function getProjectId(options: CLIOptions): string {
-  if (options.projectId) return options.projectId;
-
-  const saPath = path.resolve(process.cwd(), options.serviceAccountPath);
-  if (fs.existsSync(saPath)) {
-    const sa = JSON.parse(fs.readFileSync(saPath, "utf8"));
-    return sa.project_id;
-  }
-
-  throw new Error("Project ID not found. Use --project-id or ensure service account file exists.");
-}
-
-async function main() {
-  const { command, args, options } = parseArgs();
-
-  if (command === "help") {
-    console.log(`
+  handleReadUser,
+  handleInitCredits,
+  handleSetCredits,
+  handleListUsers,
+  handleCreditsSummary,
+} from "./cli-handlers";
+
+function printHelp(): void {
+  console.log(`
 Firebase Admin CLI
 
 Commands:
@@ -129,6 +61,13 @@ Examples:
   npx ts-node cli.ts list-users --limit 50
   npx ts-node cli.ts credits-summary
 `);
+}
+
+async function main() {
+  const { command, args, options } = parseArgs();
+
+  if (command === "help") {
+    printHelp();
     process.exit(0);
   }
 
@@ -144,130 +83,25 @@ Examples:
     const db = getFirestoreAdmin(app);
 
     switch (command) {
-      case "read-user": {
-        const userId = args[0];
-        if (!userId) {
-          console.error("❌ Error: userId is required");
-          process.exit(1);
-        }
-
-        printHeader(`📖 READ USER: ${userId}`);
-        const userData = await getUserData(db, userId, {
-          creditsCollection: options.creditsCollection,
-        });
-        printUserData(userData);
+      case "read-user":
+        await handleReadUser(db, args, options);
         break;
-      }
-
-      case "init-credits": {
-        const userId = args[0];
-        if (!userId) {
-          console.error("❌ Error: userId is required");
-          process.exit(1);
-        }
-
-        printHeader(`💰 INIT CREDITS: ${userId}`);
-        console.log(`Collection: ${options.creditsCollection}`);
-        console.log(`Limits: Text=${options.textLimit}, Image=${options.imageLimit}\n`);
-
-        const existing = await getUserData(db, userId, {
-          creditsCollection: options.creditsCollection,
-        });
-
-        if (existing.credits) {
-          console.log("⚠️  Credits already exist:");
-          console.log(`   Text: ${existing.credits.text}`);
-          console.log(`   Image: ${existing.credits.image}`);
-          console.log("\n   Use 'set-credits' to overwrite.");
-          break;
-        }
-
-        const credits = await initializeUserCredits(db, userId, {
-          collectionName: options.creditsCollection,
-          textLimit: options.textLimit,
-          imageLimit: options.imageLimit,
-        });
 
-        console.log("✅ Credits initialized:");
-        console.log(`   Text: ${credits.text}`);
-        console.log(`   Image: ${credits.image}`);
+      case "init-credits":
+        await handleInitCredits(db, args, options);
         break;
-      }
 
-      case "set-credits": {
-        const userId = args[0];
-        const text = parseInt(args[1]);
-        const image = parseInt(args[2]);
-
-        if (!userId || isNaN(text) || isNaN(image)) {
-          console.error("❌ Error: Usage: set-credits <userId> <text> <image>");
-          process.exit(1);
-        }
-
-        printHeader(`💰 SET CREDITS: ${userId}`);
-        console.log(`Setting: Text=${text}, Image=${image}\n`);
-
-        await setUserCredits(db, userId, { text, image }, options.creditsCollection);
-
-        console.log("✅ Credits set successfully!");
-
-        const updated = await getUserData(db, userId, {
-          creditsCollection: options.creditsCollection,
-        });
-        printUserData(updated);
+      case "set-credits":
+        await handleSetCredits(db, args, options);
         break;
-      }
 
-      case "list-users": {
-        const limit = parseInt(args[0]) || 100;
-
-        printHeader("👥 USERS WITH CREDITS");
-        const users = await listUsersWithCredits(db, {
-          creditsCollection: options.creditsCollection,
-          limit,
-        });
-
-        console.log(`Found ${users.length} users:\n`);
-        printSeparator("-", 80);
-        console.log(
-          "ID".padEnd(30) +
-          "Name".padEnd(20) +
-          "Text".padEnd(10) +
-          "Image".padEnd(10) +
-          "Anon"
-        );
-        printSeparator("-", 80);
-
-        users.forEach((u) => {
-          const text = u.credits?.text ?? "-";
-          const image = u.credits?.image ?? "-";
-          console.log(
-            u.userId.substring(0, 28).padEnd(30) +
-            (u.displayName || "-").substring(0, 18).padEnd(20) +
-            String(text).padEnd(10) +
-            String(image).padEnd(10) +
-            (u.isAnonymous ? "Yes" : "No")
-          );
-        });
-        printSeparator("-", 80);
+      case "list-users":
+        await handleListUsers(db, args, options);
         break;
-      }
-
-      case "credits-summary": {
-        printHeader("📊 CREDITS SUMMARY");
-        const summary = await getCreditsSummary(db, options.creditsCollection);
 
-        console.log(`Total Users:     ${summary.totalUsers}`);
-        console.log(`With Credits:    ${summary.usersWithCredits}`);
-        console.log(`Zero Credits:    ${summary.usersWithZeroCredits}`);
-        console.log();
-        console.log("Total Credits Across All Users:");
-        console.log(`  Text:  ${summary.totalText}`);
-        console.log(`  Image: ${summary.totalImage}`);
-        console.log(`  Video: ${summary.totalVideo}`);
-        console.log(`  Audio: ${summary.totalAudio}`);
+      case "credits-summary":
+        await handleCreditsSummary(db, options);
         break;
-      }
 
       default:
         console.error(`❌ Unknown command: ${command}`);

package/scripts/firestore-operations.ts

@@ -0,0 +1,111 @@
+/**
+ * Firebase Admin Firestore Operations
+ * Delete operations for Firestore data
+ */
+
+import * as admin from "firebase-admin";
+
+const BATCH_SIZE = 500;
+
+/**
+ * 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;
+}

package/scripts/firestore-queries.ts

@@ -0,0 +1,97 @@
+/**
+ * Firebase Admin Firestore Queries
+ * Query functions for reading Firestore data
+ */
+
+import * as admin from "firebase-admin";
+import type { CollectionInfo } from "./types";
+
+/**
+ * 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;
+}
+
+/**
+ * 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/firestore-seeding.ts

@@ -0,0 +1,87 @@
+/**
+ * Firebase Admin Firestore Seeding
+ * Seed operations for Firestore data
+ */
+
+import * as admin from "firebase-admin";
+import type { BatchResult } from "./types";
+
+const BATCH_SIZE = 500;
+
+/**
+ * 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;
+}