@fazetitans/fscopy 1.4.0 → 1.5.0

package/src/orchestrator.ts

@@ -7,7 +7,7 @@ import { RateLimiter } from './utils/rate-limiter.js';
 import { ProgressBarWrapper } from './utils/progress.js';
 import { loadTransferState, saveTransferState, createInitialState, validateStateForResume, deleteTransferState, StateSaver } from './state/index.js';
 import { sendWebhook } from './webhook/index.js';
-import { countDocuments, transferCollection, clearCollection, deleteOrphanDocuments, processInParallel, getDestCollectionPath, type TransferContext, type CountProgress, type DeleteOrphansProgress } from './transfer/index.js';
+import { countDocuments, transferCollection, clearCollection, deleteOrphanDocuments, processInParallel, getDestCollectionPath, buildQueryWithFilters, type TransferContext, type CountProgress, type DeleteOrphansProgress } from './transfer/index.js';
 import { initializeFirebase, checkDatabaseConnectivity, cleanupFirebase } from './firebase/index.js';
 import { loadTransformFunction } from './transform/loader.js';
 import { printSummary, formatJsonOutput } from './output/display.js';
@@ -32,10 +32,13 @@ function initializeResumeMode(config: ValidatedConfig, output: Output): ResumeRe
             throw new Error(`No state file found at ${config.stateFile}. Cannot resume without a saved state. Run without --resume to start fresh.`);
         }
 
-        const stateErrors = validateStateForResume(existingState, config);
+        const { errors: stateErrors, warnings: stateWarnings } = validateStateForResume(existingState, config);
         if (stateErrors.length > 0) {
             throw new Error(`Cannot resume: state file incompatible with current config:\n   - ${stateErrors.join('\n   - ')}`);
         }
+        for (const warning of stateWarnings) {
+            output.warn(`⚠️  ${warning}`);
+        }
 
         const completedCount = Object.values(existingState.completedDocs).reduce((sum, ids) => sum + ids.length, 0);
         output.info(`\n🔄 Resuming transfer from ${config.stateFile}`);
@@ -148,6 +151,31 @@ function displayTransferOptions(config: Config, rateLimiter: RateLimiter | null,
 export async function runTransfer(config: ValidatedConfig, argv: CliArgs, output: Output): Promise<TransferResult> {
     const startTime = Date.now();
 
+    // Graceful shutdown state
+    let stateSaverRef: StateSaver | null = null;
+    let progressBarRef: ProgressBarWrapper | null = null;
+    let interrupted = false;
+
+    const onSignal = () => {
+        if (interrupted) {
+            // Second signal: force exit
+            process.exit(130);
+        }
+        interrupted = true;
+
+        // Flush state and stop progress bar synchronously
+        stateSaverRef?.flush();
+        progressBarRef?.stop();
+
+        output.print('\n\n⚠️  Transfer interrupted. State saved for resume (use --resume).');
+        process.exit(130);
+    };
+
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
+
+    let currentStats: Stats = createEmptyStats();
+
     try {
         const { state: transferState, stats } = initializeResumeMode(config, output);
         const transformFn = await loadTransform(config, output);
@@ -156,26 +184,29 @@ export async function runTransfer(config: ValidatedConfig, argv: CliArgs, output
         const { sourceDb, destDb } = initializeFirebase(config);
         await checkDatabaseConnectivity(sourceDb, destDb, config, output);
 
-        if (transformFn && config.dryRun && config.transformSamples !== 0) {
+        if (transformFn && config.transformSamples !== 0) {
             await validateTransformWithSamples(sourceDb, config, transformFn, output);
         }
 
-        const currentStats = config.resume ? stats : createEmptyStats();
+        currentStats = config.resume ? stats : createEmptyStats();
 
         if (config.clear) {
             await clearDestinationCollections(destDb, config, currentStats, output);
         }
 
         const { progressBar } = await setupProgressTracking(sourceDb, config, currentStats, output);
+        progressBarRef = progressBar;
 
         const rateLimiter = config.rateLimit > 0 ? new RateLimiter(config.rateLimit) : null;
         displayTransferOptions(config, rateLimiter, output);
 
         const stateSaver = transferState ? new StateSaver(config.stateFile, transferState) : null;
+        stateSaverRef = stateSaver;
 
         const conflictList: ConflictInfo[] = [];
         const ctx: TransferContext = {
-            sourceDb, destDb, config, stats: currentStats, output, progressBar, transformFn, stateSaver, rateLimiter, conflictList
+            sourceDb, destDb, config, stats: currentStats, output, progressBar, transformFn,
+            stateSaver, rateLimiter, conflictList, maxDepthWarningsShown: new Set<string>(),
         };
 
         await executeTransfer(ctx, output);
@@ -206,10 +237,13 @@ export async function runTransfer(config: ValidatedConfig, argv: CliArgs, output
         const errorMessage = (error as Error).message;
         const duration = (Date.now() - startTime) / 1000;
 
-        await handleErrorOutput(config, createEmptyStats(), duration, errorMessage, output);
+        await handleErrorOutput(config, currentStats, duration, errorMessage, output);
         await cleanupFirebase();
 
-        return { success: false, stats: createEmptyStats(), duration, error: errorMessage };
+        return { success: false, stats: currentStats, duration, error: errorMessage };
+    } finally {
+        process.removeListener('SIGINT', onSignal);
+        process.removeListener('SIGTERM', onSignal);
     }
 }
 
@@ -295,62 +329,40 @@ async function setupProgressTracking(
     if (!output.isQuiet) {
         output.info('📊 Counting documents...');
 
-        for (const collection of config.collections) {
-            let rootCount = 0;
-            let subcollectionInstances = 0;
-            const subcollectionNames = new Set<string>();
-            const excludedNames = new Set<string>();
-            let lastLog = Date.now();
-            let showedScanLine = false;
-
-            if (canWriteProgress(output)) {
-                process.stdout.write(`   Counting ${collection}...`);
-                showedScanLine = true;
-            }
+        if (config.includeSubcollections) {
+            // Use .count() aggregation for root collections (1 read per collection)
+            // Subcollection docs will be counted lazily during transfer to avoid
+            // reading every document twice (once for count, once for transfer)
+            for (const collection of config.collections) {
+                const query = buildQueryWithFilters(sourceDb, collection, config, 0);
+                const countSnap = await query.count().get();
+                let rootCount = countSnap.data().count;
+
+                if (config.limit > 0) {
+                    rootCount = Math.min(rootCount, config.limit);
+                }
 
-            const countProgress: CountProgress = {
-                onCollection: (_path, count) => {
-                    rootCount = count;
-                },
-                onSubcollection: (path) => {
-                    subcollectionInstances++;
-                    const segments = path.split('/');
-                    subcollectionNames.add(segments[segments.length - 1]);
-
-                    if (!canWriteProgress(output)) return;
-                    const now = Date.now();
-                    if (now - lastLog > PROGRESS_LOG_INTERVAL_MS) {
-                        process.stdout.write(`\r   Scanning ${collection}... (${subcollectionInstances} subcollections found)`);
-                        showedScanLine = true;
-                        lastLog = now;
-                    }
-                },
-                onSubcollectionExcluded: (name) => {
-                    excludedNames.add(name);
-                },
-            };
-
-            const collectionTotal = await countDocuments(sourceDb, collection, config, 0, countProgress);
-            totalDocs += collectionTotal;
-
-            // Clear live indicator line
-            if (showedScanLine && canWriteProgress(output)) {
-                clearLine();
+                totalDocs += rootCount;
+                output.info(`   ${collection}: ${rootCount} documents (+ subcollections)`);
             }
 
-            // Print collection summary
-            output.info(`   ${collection}: ${rootCount} documents`);
-
-            if (subcollectionInstances > 0) {
-                const subDocs = collectionTotal - rootCount;
-                output.info(`      + ${subDocs} in subcollections (${formatNameList(subcollectionNames)})`);
-            }
-            if (excludedNames.size > 0) {
-                output.info(`      Excluded: ${formatNameList(excludedNames)}`);
+            output.info(`\n   Total: ${totalDocs} root documents (subcollections counted during transfer)\n`);
+        } else {
+            // Without subcollections, use the efficient countDocuments (already uses .count())
+            for (const collection of config.collections) {
+                const countProgress: CountProgress = {
+                    onCollection: (_path, count) => {
+                        output.info(`   ${collection}: ${count} documents`);
+                    },
+                };
+
+                const collectionTotal = await countDocuments(sourceDb, collection, config, 0, countProgress);
+                totalDocs += collectionTotal;
             }
+
+            output.info(`\n   Total: ${totalDocs} documents to transfer\n`);
         }
 
-        output.info(`\n   Total: ${totalDocs} documents to transfer\n`);
         if (canWriteProgress(output)) {
             progressBar.start(totalDocs, stats);
         }

package/src/state/index.ts

@@ -2,6 +2,10 @@ import fs from 'node:fs';
 import { STATE_SAVE_INTERVAL_MS, STATE_SAVE_BATCH_INTERVAL } from '../constants.js';
 import type { Config, ValidatedConfig, TransferState, Stats } from '../types.js';
 
+function stderrWarn(message: string): void {
+    process.stderr.write(`${message}\n`);
+}
+
 export const STATE_VERSION = 1;
 
 // =============================================================================
@@ -192,18 +196,33 @@ export function loadTransferState(stateFile: string): TransferState | null {
             return null;
         }
         const content = fs.readFileSync(stateFile, 'utf-8');
-        const state = JSON.parse(content) as TransferState;
+
+        let state: TransferState;
+        try {
+            state = JSON.parse(content) as TransferState;
+        } catch {
+            stderrWarn(`⚠️  State file is corrupted (invalid JSON): ${stateFile}`);
+            stderrWarn('   Delete the file and restart, or run without --resume.');
+            return null;
+        }
+
+        if (!state.version) {
+            stderrWarn(`⚠️  State file is missing version field: ${stateFile}`);
+            stderrWarn('   The file may be corrupted. Delete it and restart.');
+            return null;
+        }
 
         if (state.version !== STATE_VERSION) {
-            console.warn(
+            stderrWarn(
                 `⚠️  State file version mismatch (expected ${STATE_VERSION}, got ${state.version})`
             );
+            stderrWarn('   Delete the file and restart to use the current format.');
             return null;
         }
 
         return state;
     } catch (error) {
-        console.error(`⚠️  Failed to load state file: ${(error as Error).message}`);
+        stderrWarn(`⚠️  Failed to read state file: ${(error as Error).message}`);
         return null;
     }
 }
@@ -228,7 +247,7 @@ export function saveTransferState(stateFile: string, state: TransferState): void
             // Ignore cleanup errors
         }
         // Log but don't throw - state save failure shouldn't stop the transfer
-        console.error(`⚠️  Failed to save state file: ${(error as Error).message}`);
+        stderrWarn(`⚠️  Failed to save state file: ${(error as Error).message}`);
     }
 }
 
@@ -262,8 +281,14 @@ export function createInitialState(config: ValidatedConfig): TransferState {
     };
 }
 
-export function validateStateForResume(state: TransferState, config: Config): string[] {
+export interface ResumeValidation {
+    errors: string[];
+    warnings: string[];
+}
+
+export function validateStateForResume(state: TransferState, config: Config): ResumeValidation {
     const errors: string[] = [];
+    const warnings: string[] = [];
 
     if (state.sourceProject !== config.sourceProject) {
         errors.push(
@@ -276,7 +301,7 @@ export function validateStateForResume(state: TransferState, config: Config): st
         );
     }
 
-    // Check if collections are compatible (state collections should be subset of config)
+    // Check if state collections are still in config
     const configCollections = new Set(config.collections);
     for (const col of state.collections) {
         if (!configCollections.has(col)) {
@@ -284,25 +309,16 @@ export function validateStateForResume(state: TransferState, config: Config): st
         }
     }
 
-    return errors;
-}
-
-export function isDocCompleted(
-    state: TransferState,
-    collectionPath: string,
-    docId: string
-): boolean {
-    const completedInCollection = state.completedDocs[collectionPath];
-    return completedInCollection ? completedInCollection.includes(docId) : false;
-}
-
-export function markDocCompleted(
-    state: TransferState,
-    collectionPath: string,
-    docId: string
-): void {
-    if (!state.completedDocs[collectionPath]) {
-        state.completedDocs[collectionPath] = [];
+    // Check for orphaned completedDocs entries (subcollections or removed collections)
+    const stateCollections = new Set(state.collections);
+    for (const collectionPath of Object.keys(state.completedDocs)) {
+        const rootCollection = collectionPath.split('/')[0];
+        if (!configCollections.has(rootCollection) && !stateCollections.has(rootCollection)) {
+            warnings.push(
+                `State has completed docs for "${collectionPath}" which is no longer in config (will be ignored)`
+            );
+        }
     }
-    state.completedDocs[collectionPath].push(docId);
+
+    return { errors, warnings };
 }

package/src/transfer/clear.ts

@@ -2,8 +2,8 @@ import type { Firestore, QueryDocumentSnapshot } from 'firebase-admin/firestore'
 import type { Config } from '../types.js';
 import type { Output } from '../utils/output.js';
 import { withRetry } from '../utils/retry.js';
-import { matchesExcludePattern } from '../utils/patterns.js';
-import { getSubcollections, getDestCollectionPath } from './helpers.js';
+import { getFilteredSubcollections, getDestCollectionPath } from './helpers.js';
+import { CLEAR_PAGE_SIZE } from '../constants.js';
 
 async function clearDocSubcollections(
     db: Firestore,
@@ -13,11 +13,9 @@ async function clearDocSubcollections(
     output: Output
 ): Promise<number> {
     let deletedCount = 0;
-    const subcollections = await getSubcollections(doc.ref);
+    const subcollections = await getFilteredSubcollections(doc.ref, config.exclude);
 
     for (const subId of subcollections) {
-        if (matchesExcludePattern(subId, config.exclude)) continue;
-
         const subPath = `${collectionPath}/${doc.id}/${subId}`;
         deletedCount += await clearCollection(db, subPath, config, output, true);
     }
@@ -61,42 +59,45 @@ export async function clearCollection(
     output: Output,
     includeSubcollections: boolean
 ): Promise<number> {
-    const snapshot = await db.collection(collectionPath).get();
-    if (snapshot.empty) return 0;
-
     let deletedCount = 0;
-
-    // Delete subcollections first if enabled
-    if (includeSubcollections) {
-        for (const doc of snapshot.docs) {
-            deletedCount += await clearDocSubcollections(db, doc, collectionPath, config, output);
+    let lastDoc: QueryDocumentSnapshot | undefined;
+    const pageSize = Math.min(config.batchSize, CLEAR_PAGE_SIZE);
+
+    // Paginate through the collection to avoid loading all docs into memory
+    while (true) {
+        let query = db.collection(collectionPath).select().limit(pageSize);
+        if (lastDoc) {
+            query = query.startAfter(lastDoc);
         }
-    }
-
-    // Delete documents in batches
-    for (let i = 0; i < snapshot.docs.length; i += config.batchSize) {
-        const batch = snapshot.docs.slice(i, i + config.batchSize);
-        deletedCount += await deleteBatch(db, batch, collectionPath, config, output);
-    }
 
-    return deletedCount;
-}
-
-async function clearOrphanSubcollections(
-    destDb: Firestore,
-    doc: QueryDocumentSnapshot,
-    destCollectionPath: string,
-    config: Config,
-    output: Output
-): Promise<number> {
-    let deletedCount = 0;
-    const subcollections = await getSubcollections(doc.ref);
+        const snapshot = await query.get();
+        if (snapshot.empty) break;
+
+        // Delete subcollections first if enabled
+        if (includeSubcollections) {
+            for (const doc of snapshot.docs) {
+                deletedCount += await clearDocSubcollections(
+                    db,
+                    doc,
+                    collectionPath,
+                    config,
+                    output
+                );
+            }
+        }
 
-    for (const subId of subcollections) {
-        if (matchesExcludePattern(subId, config.exclude)) continue;
+        // Delete documents in batches
+        for (let i = 0; i < snapshot.docs.length; i += config.batchSize) {
+            const batch = snapshot.docs.slice(i, i + config.batchSize);
+            deletedCount += await deleteBatch(db, batch, collectionPath, config, output);
+        }
 
-        const subPath = `${destCollectionPath}/${doc.id}/${subId}`;
-        deletedCount += await clearCollection(destDb, subPath, config, output, true);
+        // In dry-run mode, we need to paginate using the last doc since docs aren't actually deleted
+        if (config.dryRun) {
+            lastDoc = snapshot.docs[snapshot.docs.length - 1];
+            if (snapshot.docs.length < pageSize) break;
+        }
+        // In live mode, docs are deleted so we always query from the start (no lastDoc needed)
     }
 
     return deletedCount;
@@ -114,7 +115,7 @@ async function deleteOrphanBatch(
 
     for (const doc of batch) {
         if (config.includeSubcollections) {
-            deletedCount += await clearOrphanSubcollections(
+            deletedCount += await clearDocSubcollections(
                 destDb,
                 doc,
                 destCollectionPath,
@@ -157,10 +158,8 @@ async function processSubcollectionOrphansWithProgress(
     let deletedCount = 0;
 
     for (const sourceDoc of sourceSnapshot.docs) {
-        const sourceSubcollections = await getSubcollections(sourceDoc.ref);
+        const sourceSubcollections = await getFilteredSubcollections(sourceDoc.ref, config.exclude);
         for (const subId of sourceSubcollections) {
-            if (matchesExcludePattern(subId, config.exclude)) continue;
-
             const subPath = `${sourceCollectionPath}/${sourceDoc.id}/${subId}`;
             progress?.onSubcollectionScan?.(subPath);
             deletedCount += await deleteOrphanDocuments(
@@ -196,42 +195,79 @@ export async function deleteOrphanDocuments(
 
     progress?.onScanStart?.(destCollectionPath);
 
-    const sourceSnapshot = await sourceDb.collection(sourceCollectionPath).select().get();
-    const sourceIds = new Set(sourceSnapshot.docs.map((doc) => doc.id));
-
-    const destSnapshot = await destDb.collection(destCollectionPath).select().get();
-    const orphanDocs = destSnapshot.docs.filter((doc) => !sourceIds.has(doc.id));
-
-    progress?.onScanComplete?.(destCollectionPath, orphanDocs.length, destSnapshot.size);
+    // Paginate source to build ID set (strings only, minimal memory)
+    const sourceIds = new Set<string>();
+    let lastSourceDoc: QueryDocumentSnapshot | undefined;
+    while (true) {
+        let query = sourceDb.collection(sourceCollectionPath).select().limit(CLEAR_PAGE_SIZE);
+        if (lastSourceDoc) query = query.startAfter(lastSourceDoc);
+        const snapshot = await query.get();
+        if (snapshot.empty) break;
+        for (const doc of snapshot.docs) sourceIds.add(doc.id);
+        lastSourceDoc = snapshot.docs[snapshot.docs.length - 1];
+        if (snapshot.size < CLEAR_PAGE_SIZE) break;
+    }
 
+    // Paginate dest and find/delete orphans in batches
     let deletedCount = 0;
+    let totalDest = 0;
+    let totalOrphans = 0;
+    let lastDestDoc: QueryDocumentSnapshot | undefined;
+
+    while (true) {
+        let query = destDb.collection(destCollectionPath).select().limit(CLEAR_PAGE_SIZE);
+        if (lastDestDoc) query = query.startAfter(lastDestDoc);
+        const snapshot = await query.get();
+        if (snapshot.empty) break;
+
+        totalDest += snapshot.size;
+        const orphanDocs = snapshot.docs.filter((doc) => !sourceIds.has(doc.id));
+        totalOrphans += orphanDocs.length;
+
+        if (orphanDocs.length > 0) {
+            output.logInfo(`Found ${orphanDocs.length} orphan documents in ${destCollectionPath}`);
+
+            for (let i = 0; i < orphanDocs.length; i += config.batchSize) {
+                const batch = orphanDocs.slice(i, i + config.batchSize);
+                deletedCount += await deleteOrphanBatch(
+                    destDb,
+                    batch,
+                    destCollectionPath,
+                    config,
+                    output
+                );
+                progress?.onBatchDeleted?.(destCollectionPath, deletedCount, totalOrphans);
+            }
+        }
 
-    if (orphanDocs.length > 0) {
-        output.logInfo(`Found ${orphanDocs.length} orphan documents in ${destCollectionPath}`);
+        lastDestDoc = snapshot.docs[snapshot.docs.length - 1];
+        if (snapshot.size < CLEAR_PAGE_SIZE) break;
+    }
 
-        for (let i = 0; i < orphanDocs.length; i += config.batchSize) {
-            const batch = orphanDocs.slice(i, i + config.batchSize);
-            deletedCount += await deleteOrphanBatch(
+    progress?.onScanComplete?.(destCollectionPath, totalOrphans, totalDest);
+
+    // Process subcollection orphans (paginate source docs)
+    if (config.includeSubcollections) {
+        let lastSubDoc: QueryDocumentSnapshot | undefined;
+        while (true) {
+            let query = sourceDb.collection(sourceCollectionPath).select().limit(CLEAR_PAGE_SIZE);
+            if (lastSubDoc) query = query.startAfter(lastSubDoc);
+            const snapshot = await query.get();
+            if (snapshot.empty) break;
+
+            deletedCount += await processSubcollectionOrphansWithProgress(
+                sourceDb,
                 destDb,
-                batch,
-                destCollectionPath,
+                snapshot,
+                sourceCollectionPath,
                 config,
-                output
+                output,
+                progress
             );
-            progress?.onBatchDeleted?.(destCollectionPath, deletedCount, orphanDocs.length);
-        }
-    }
 
-    if (config.includeSubcollections) {
-        deletedCount += await processSubcollectionOrphansWithProgress(
-            sourceDb,
-            destDb,
-            sourceSnapshot,
-            sourceCollectionPath,
-            config,
-            output,
-            progress
-        );
+            lastSubDoc = snapshot.docs[snapshot.docs.length - 1];
+            if (snapshot.size < CLEAR_PAGE_SIZE) break;
+        }
     }
 
     return deletedCount;

package/src/transfer/count.ts

@@ -1,7 +1,8 @@
-import type { Firestore, Query } from 'firebase-admin/firestore';
+import type { Firestore, Query, QueryDocumentSnapshot } from 'firebase-admin/firestore';
 import type { Config } from '../types.js';
 import { matchesExcludePattern } from '../utils/patterns.js';
-import { getSubcollections } from './helpers.js';
+import { getSubcollections, buildQueryWithFilters } from './helpers.js';
+import { CLEAR_PAGE_SIZE } from '../constants.js';
 
 export interface CountProgress {
     onCollection?: (path: string, count: number) => void;
@@ -9,21 +10,6 @@ export interface CountProgress {
     onSubcollectionExcluded?: (name: string) => void;
 }
 
-function buildQueryWithFilters(
-    sourceDb: Firestore,
-    collectionPath: string,
-    config: Config,
-    depth: number
-): Query {
-    let query: Query = sourceDb.collection(collectionPath);
-    if (depth === 0 && config.where.length > 0) {
-        for (const filter of config.where) {
-            query = query.where(filter.field, filter.operator, filter.value);
-        }
-    }
-    return query;
-}
-
 async function countWithSubcollections(
     sourceDb: Firestore,
     query: Query,
@@ -32,30 +18,53 @@ async function countWithSubcollections(
     depth: number,
     progress?: CountProgress
 ): Promise<number> {
-    // Apply limit at root level only
-    if (depth === 0 && config.limit > 0) {
-        query = query.limit(config.limit);
-    }
+    const userLimit = depth === 0 && config.limit > 0 ? config.limit : 0;
+    let rootCount = 0;
+    let subCount = 0;
+    let lastDoc: QueryDocumentSnapshot | undefined;
+
+    while (true) {
+        let pageSize = CLEAR_PAGE_SIZE;
+        if (userLimit > 0) {
+            const remaining = userLimit - rootCount;
+            if (remaining <= 0) break;
+            pageSize = Math.min(pageSize, remaining);
+        }
 
-    const snapshot = await query.select().get();
-    let count = snapshot.size;
+        let pageQuery = query.select().limit(pageSize);
+        if (lastDoc) {
+            pageQuery = pageQuery.startAfter(lastDoc);
+        }
 
-    if (depth === 0 && progress?.onCollection) {
-        progress.onCollection(collectionPath, snapshot.size);
+        const snapshot = await pageQuery.get();
+        if (snapshot.empty) break;
+
+        rootCount += snapshot.size;
+
+        if (depth === 0 && progress?.onCollection) {
+            progress.onCollection(collectionPath, rootCount);
+        }
+
+        for (const doc of snapshot.docs) {
+            subCount += await countSubcollectionsForDoc(
+                sourceDb,
+                doc,
+                collectionPath,
+                config,
+                depth,
+                progress
+            );
+        }
+
+        lastDoc = snapshot.docs[snapshot.docs.length - 1];
+        if (snapshot.size < pageSize) break;
     }
 
-    for (const doc of snapshot.docs) {
-        count += await countSubcollectionsForDoc(
-            sourceDb,
-            doc,
-            collectionPath,
-            config,
-            depth,
-            progress
-        );
+    if (rootCount === 0 && depth === 0 && progress?.onCollection) {
+        progress.onCollection(collectionPath, 0);
     }
 
-    return count;
+    return rootCount + subCount;
 }
 
 async function countSubcollectionsForDoc(