appwrite-utils-cli 1.7.6 → 1.7.8

package/SELECTION_DIALOGS.md

@@ -0,0 +1,146 @@
+# Selection Dialogs System
+
+## Overview
+
+The `SelectionDialogs` class provides a comprehensive interactive selection system for the enhanced sync flow in the Appwrite Utils CLI. It enables users to select databases, tables/collections, and storage buckets with visual indicators for configured vs new items.
+
+## Features
+
+- **Visual Indicators**: ✅ for configured items, ○ for new items
+- **Multi-Selection Support**: Checkbox-style selection with "Select All" functionality
+- **Configuration Awareness**: Detects and highlights existing configurations
+- **Grouped Display**: Organizes buckets by database for better context
+- **Comprehensive Confirmation**: Shows detailed summary before sync execution
+- **Graceful Error Handling**: Proper error messages and cancellation support
+- **Type Safety**: Full TypeScript support with proper interfaces
+
+## Main Functions
+
+### `promptForExistingConfig(configuredItems: any[])`
+Prompts user about existing configuration with options to:
+- Sync existing configured items
+- Add/remove items from configuration
+
+### `selectDatabases(availableDatabases, configuredDatabases, options?)`
+Interactive database selection with:
+- Visual indicators for configured vs new databases
+- "Select All" functionality
+- Filtering options (new only, default selections)
+
+### `selectTablesForDatabase(databaseId, databaseName, availableTables, configuredTables, options?)`
+Table/collection selection for a specific database with:
+- Database context display
+- Table selection with indicators
+- Multi-selection support
+
+### `selectBucketsForDatabases(selectedDatabaseIds, availableBuckets, configuredBuckets, options?)`
+Storage bucket selection with:
+- Grouping by database
+- Relevance filtering (only buckets for selected databases)
+- Ungrouped/general storage support
+
+### `confirmSyncSelection(selectionSummary: SyncSelectionSummary)`
+Final confirmation dialog showing:
+- Complete selection summary
+- Statistics (total, new, existing items)
+- Detailed breakdown by category
+
+## Usage Example
+
+```typescript
+import { SelectionDialogs } from './shared/selectionDialogs.js';
+import type { Models } from 'node-appwrite';
+
+// 1. Check for existing configuration
+const { syncExisting, modifyConfiguration } = await SelectionDialogs.promptForExistingConfig(configuredDatabases);
+
+if (modifyConfiguration) {
+  // 2. Select databases
+  const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
+    availableDatabases,
+    configuredDatabases,
+    { showSelectAll: true }
+  );
+
+  // 3. Select tables for each database
+  const tableSelectionsMap = new Map<string, string[]>();
+  for (const databaseId of selectedDatabaseIds) {
+    const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+      databaseId,
+      databaseName,
+      availableTables,
+      configuredTables
+    );
+    tableSelectionsMap.set(databaseId, selectedTableIds);
+  }
+
+  // 4. Select buckets
+  const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(
+    selectedDatabaseIds,
+    availableBuckets,
+    configuredBuckets
+  );
+
+  // 5. Create selection summary and confirm
+  const selectionSummary = SelectionDialogs.createSyncSelectionSummary(
+    databaseSelections,
+    bucketSelections
+  );
+
+  const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+
+  if (confirmed) {
+    // Proceed with sync operation
+  }
+}
+```
+
+## Configuration Options
+
+### Database Selection Options
+- `showSelectAll`: Show "Select All" option (default: true)
+- `allowNewOnly`: Only show new/unconfigured databases (default: false)
+- `defaultSelected`: Array of database IDs to pre-select
+
+### Table Selection Options
+- `showSelectAll`: Show "Select All" option (default: true)
+- `allowNewOnly`: Only show new/unconfigured tables (default: false)
+- `defaultSelected`: Array of table IDs to pre-select
+- `showDatabaseContext`: Show database name in header (default: true)
+
+### Bucket Selection Options
+- `showSelectAll`: Show "Select All" option (default: true)
+- `allowNewOnly`: Only show new/unconfigured buckets (default: false)
+- `defaultSelected`: Array of bucket IDs to pre-select
+- `groupByDatabase`: Group buckets by database (default: true)
+
+## Interfaces
+
+### `SyncSelectionSummary`
+Contains complete selection information:
+- `databases`: Array of selected databases with their tables
+- `buckets`: Array of selected buckets
+- `totalDatabases/Tables/Buckets`: Count of selected items
+- `newItems/existingItems`: Breakdown of new vs existing configurations
+
+### `DatabaseSelection`
+Represents a selected database:
+- `databaseId/databaseName`: Database identification
+- `tableIds/tableNames`: Selected tables for this database
+- `isNew`: Whether this is a new configuration
+
+### `BucketSelection`
+Represents a selected bucket:
+- `bucketId/bucketName`: Bucket identification
+- `databaseId/databaseName`: Associated database (if applicable)
+- `isNew`: Whether this is a new configuration
+
+## Integration
+
+The selection dialogs are designed to integrate seamlessly with the existing CLI infrastructure:
+
+- Uses `MessageFormatter` for consistent styling
+- Integrates with existing logging system
+- Follows established error handling patterns
+- Compatible with existing configuration management
+- Uses inquirer.js for interactive prompts

package/dist/adapters/DatabaseAdapter.d.ts

@@ -72,6 +72,7 @@ export interface BulkDeleteRowsParams {
     databaseId: string;
     tableId: string;
     rowIds: string[];
+    batchSize?: number;
 }
 export interface CreateIndexParams {
     databaseId: string;

package/dist/adapters/LegacyAdapter.js

@@ -7,6 +7,7 @@
  * older Appwrite instances.
  */
 import { Query } from "node-appwrite";
+import { chunk } from "es-toolkit";
 import { BaseAdapter, AdapterError, UnsupportedOperationError } from './DatabaseAdapter.js';
 /**
  * LegacyAdapter - Translates TablesDB calls to legacy Databases API
@@ -310,13 +311,24 @@ export class LegacyAdapter extends BaseAdapter {
     }
     async bulkDeleteRows(params) {
         try {
-            // Try to use deleteDocuments with queries first (more efficient)
-            const queries = params.rowIds.map(id => Query.equal('$id', id));
+            let queries;
+            // Wipe mode: use Query.limit for deleting without fetching
+            if (params.rowIds.length === 0) {
+                const batchSize = params.batchSize || 250;
+                queries = [Query.limit(batchSize)];
+            }
+            // Specific IDs mode: chunk into batches of 80-90 to stay within Appwrite limits
+            // (max 100 IDs per Query.equal, and queries must be < 4096 chars total)
+            else {
+                const ID_BATCH_SIZE = 85; // Safe batch size for Query.equal
+                const idBatches = chunk(params.rowIds, ID_BATCH_SIZE);
+                queries = idBatches.map(batch => Query.equal('$id', batch));
+            }
             const result = await this.databases.deleteDocuments(params.databaseId, params.tableId, // Maps tableId to collectionId
             queries);
             return {
                 data: result,
-                total: params.rowIds.length
+                total: params.rowIds.length || result.total || 0
             };
         }
         catch (error) {

package/dist/adapters/TablesDBAdapter.js

@@ -6,6 +6,7 @@
  * and returns Models.Row instead of Models.Document.
  */
 import { Query } from "node-appwrite";
+import { chunk } from "es-toolkit";
 import { BaseAdapter, AdapterError } from './DatabaseAdapter.js';
 /**
  * TablesDBAdapter implementation for native TablesDB API
@@ -270,8 +271,19 @@ export class TablesDBAdapter extends BaseAdapter {
     }
     async bulkDeleteRows(params) {
         try {
-            // Convert rowIds to queries for the deleteRows API
-            const queries = params.rowIds.map(id => Query.equal('$id', id));
+            let queries;
+            // Wipe mode: use Query.limit for deleting without fetching
+            if (params.rowIds.length === 0) {
+                const batchSize = params.batchSize || 250;
+                queries = [Query.limit(batchSize)];
+            }
+            // Specific IDs mode: chunk into batches of 80-90 to stay within Appwrite limits
+            // (max 100 IDs per Query.equal, and queries must be < 4096 chars total)
+            else {
+                const ID_BATCH_SIZE = 85; // Safe batch size for Query.equal
+                const idBatches = chunk(params.rowIds, ID_BATCH_SIZE);
+                queries = idBatches.map(batch => Query.equal('$id', batch));
+            }
             const result = await this.tablesDB.deleteRows({
                 databaseId: params.databaseId,
                 tableId: params.tableId,
@@ -279,7 +291,7 @@ export class TablesDBAdapter extends BaseAdapter {
             });
             return {
                 data: result,
-                total: params.rowIds.length
+                total: params.rowIds.length || result.total || 0
             };
         }
         catch (error) {

package/dist/cli/commands/databaseCommands.js

@@ -3,32 +3,95 @@ import chalk from "chalk";
 import { join } from "node:path";
 import { MessageFormatter } from "../../shared/messageFormatter.js";
 import { ConfirmationDialogs } from "../../shared/confirmationDialogs.js";
+import { SelectionDialogs } from "../../shared/selectionDialogs.js";
+import { logger } from "../../shared/logging.js";
 import { fetchAllDatabases } from "../../databases/methods.js";
 import { listBuckets } from "../../storage/methods.js";
 import { getFunction, downloadLatestFunctionDeployment } from "../../functions/methods.js";
 export const databaseCommands = {
     async syncDb(cli) {
         MessageFormatter.progress("Pushing local configuration to Appwrite...", { prefix: "Database" });
-        const databases = await cli.selectDatabases(cli.getLocalDatabases(), chalk.blue("Select local databases to push:"), true);
-        if (!databases.length) {
-            MessageFormatter.warning("No databases selected. Skipping database sync.", { prefix: "Database" });
-            return;
-        }
         try {
-            // Loop through each database and prompt for collections specific to that database
-            for (const database of databases) {
-                MessageFormatter.info(`\n📦 Configuring push for database: ${database.name}`, { prefix: "Database" });
-                const collections = await cli.selectCollectionsAndTables(database, cli.controller.database, chalk.blue(`Select collections/tables to push to "${database.name}":`), true, // multiSelect
+            // Initialize controller
+            await cli.controller.init();
+            // Get available and configured databases
+            const availableDatabases = await fetchAllDatabases(cli.controller.database);
+            const configuredDatabases = cli.controller.config?.databases || [];
+            // Get local collections for selection
+            const localCollections = cli.getLocalCollections();
+            // Prompt about existing configuration
+            const { syncExisting, modifyConfiguration } = await SelectionDialogs.promptForExistingConfig(configuredDatabases);
+            // Select databases
+            const selectedDatabaseIds = await SelectionDialogs.selectDatabases(availableDatabases, configuredDatabases, { showSelectAll: true, allowNewOnly: !syncExisting });
+            if (selectedDatabaseIds.length === 0) {
+                MessageFormatter.warning("No databases selected. Skipping database sync.", { prefix: "Database" });
+                return;
+            }
+            // Select tables/collections for each database using the existing method
+            const tableSelectionsMap = new Map();
+            const availableTablesMap = new Map();
+            for (const databaseId of selectedDatabaseIds) {
+                const database = availableDatabases.find(db => db.$id === databaseId);
+                // Use the existing selectCollectionsAndTables method
+                const selectedCollections = await cli.selectCollectionsAndTables(database, cli.controller.database, chalk.blue(`Select collections/tables to push to "${database.name}":`), true, // multiSelect
                 true // prefer local
                 );
-                if (collections.length === 0) {
+                // Map selected collections to table IDs
+                const selectedTableIds = selectedCollections.map((c) => c.$id || c.id);
+                // Store selections
+                tableSelectionsMap.set(databaseId, selectedTableIds);
+                availableTablesMap.set(databaseId, selectedCollections);
+                if (selectedCollections.length === 0) {
                     MessageFormatter.warning(`No collections selected for database "${database.name}". Skipping.`, { prefix: "Database" });
                     continue;
                 }
-                // Push selected collections to this specific database
-                await cli.controller.syncDb([database], collections);
-                MessageFormatter.success(`Pushed ${collections.length} collection(s) to database "${database.name}"`, { prefix: "Database" });
             }
+            // Ask if user wants to select buckets
+            const { selectBuckets } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "selectBuckets",
+                    message: "Do you want to select storage buckets to sync as well?",
+                    default: false,
+                },
+            ]);
+            let bucketSelections = [];
+            if (selectBuckets) {
+                // Get available and configured buckets
+                try {
+                    const availableBucketsResponse = await listBuckets(cli.controller.storage);
+                    const availableBuckets = availableBucketsResponse.buckets || [];
+                    const configuredBuckets = cli.controller.config?.buckets || [];
+                    if (availableBuckets.length === 0) {
+                        MessageFormatter.warning("No storage buckets available in remote instance.", { prefix: "Database" });
+                    }
+                    else {
+                        // Select buckets using SelectionDialogs
+                        const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(selectedDatabaseIds, availableBuckets, configuredBuckets, { showSelectAll: true, groupByDatabase: true });
+                        if (selectedBucketIds.length > 0) {
+                            // Create BucketSelection objects
+                            bucketSelections = SelectionDialogs.createBucketSelection(selectedBucketIds, availableBuckets, configuredBuckets, availableDatabases);
+                            MessageFormatter.info(`Selected ${bucketSelections.length} storage bucket(s)`, { prefix: "Database" });
+                        }
+                    }
+                }
+                catch (error) {
+                    MessageFormatter.warning("Failed to fetch storage buckets. Continuing with databases only.", { prefix: "Database" });
+                    logger.warn("Storage bucket fetch failed during syncDb", { error: error instanceof Error ? error.message : String(error) });
+                }
+            }
+            // Create DatabaseSelection objects
+            const databaseSelections = SelectionDialogs.createDatabaseSelection(selectedDatabaseIds, availableDatabases, tableSelectionsMap, configuredDatabases, availableTablesMap);
+            // Show confirmation summary
+            const selectionSummary = SelectionDialogs.createSyncSelectionSummary(databaseSelections, bucketSelections);
+            const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+            if (!confirmed) {
+                MessageFormatter.info("Sync operation cancelled by user", { prefix: "Database" });
+                return;
+            }
+            // Perform selective sync using the controller
+            MessageFormatter.progress("Starting selective sync...", { prefix: "Database" });
+            await cli.controller.selectiveSync(databaseSelections, bucketSelections);
             MessageFormatter.success("\n✅ All database configurations pushed successfully!", { prefix: "Database" });
             // Then handle functions if requested
             const { syncFunctions } = await inquirer.prompt([
@@ -73,19 +136,23 @@ export const databaseCommands = {
         ]);
         if (syncDatabases) {
             const remoteDatabases = await fetchAllDatabases(cli.controller.database);
-            // Use the controller's synchronizeConfigurations method which handles collections properly
-            MessageFormatter.progress("Pulling collections and generating collection files...", { prefix: "Collections" });
-            await cli.controller.synchronizeConfigurations(remoteDatabases);
-            // Also configure buckets for any new databases
+            // First, prepare the combined database list for bucket configuration
             const localDatabases = cli.controller.config?.databases || [];
-            const updatedConfig = await cli.configureBuckets({
+            const allDatabases = [
+                ...localDatabases,
+                ...remoteDatabases.filter((rd) => !localDatabases.some((ld) => ld.name === rd.name)),
+            ];
+            // Configure buckets FIRST to get user selections before writing config
+            MessageFormatter.progress("Configuring storage buckets...", { prefix: "Buckets" });
+            const configWithBuckets = await cli.configureBuckets({
                 ...cli.controller.config,
-                databases: [
-                    ...localDatabases,
-                    ...remoteDatabases.filter((rd) => !localDatabases.some((ld) => ld.name === rd.name)),
-                ],
+                databases: allDatabases,
             });
-            cli.controller.config = updatedConfig;
+            // Update controller config with bucket selections
+            cli.controller.config = configWithBuckets;
+            // Now synchronize configurations with the updated config that includes bucket selections
+            MessageFormatter.progress("Pulling collections and generating collection files...", { prefix: "Collections" });
+            await cli.controller.synchronizeConfigurations(remoteDatabases, configWithBuckets);
         }
         // Then sync functions
         const { syncFunctions } = await inquirer.prompt([

package/dist/collections/wipeOperations.d.ts

@@ -10,7 +10,7 @@ export declare const wipeAllTables: (adapter: DatabaseAdapter, databaseId: strin
     tableName: string;
 }[]>;
 /**
- * Optimized streaming deletion of all rows from a table
- * Uses bulk deletion when available, falls back to optimized individual deletion
+ * Optimized deletion of all rows from a table using direct bulk deletion
+ * Uses Query.limit() to delete rows without fetching IDs first
  */
 export declare const wipeTableRows: (adapter: DatabaseAdapter, databaseId: string, tableId: string) => Promise<void>;

package/dist/collections/wipeOperations.js

@@ -2,7 +2,7 @@ import { Databases, Query, } from "node-appwrite";
 import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { ProgressManager } from "../shared/progressManager.js";
-import { isRetryableError, isBulkNotSupportedError, isCriticalError } from "../shared/errorUtils.js";
+import { isRetryableError, isCriticalError } from "../shared/errorUtils.js";
 import { delay } from "../utils/helperFunctions.js";
 import { chunk } from "es-toolkit";
 import pLimit from "p-limit";
@@ -167,82 +167,54 @@ export const wipeAllTables = async (adapter, databaseId) => {
     return deleted;
 };
 /**
- * Optimized streaming deletion of all rows from a table
- * Uses bulk deletion when available, falls back to optimized individual deletion
+ * Optimized deletion of all rows from a table using direct bulk deletion
+ * Uses Query.limit() to delete rows without fetching IDs first
  */
 export const wipeTableRows = async (adapter, databaseId, tableId) => {
     try {
-        // Configuration for optimized deletion
-        const FETCH_BATCH_SIZE = 1000; // How many to fetch per query
-        const BULK_DELETE_BATCH_SIZE = 500; // How many to bulk delete at once
-        const INDIVIDUAL_DELETE_BATCH_SIZE = 200; // For fallback individual deletion
-        const MAX_CONCURRENT_OPERATIONS = 10; // Concurrent bulk/individual operations
+        // Check if bulk deletion is available
+        if (!adapter.bulkDeleteRows) {
+            MessageFormatter.error("Bulk deletion not available for this adapter - wipe operation not supported", new Error("bulkDeleteRows not available"), { prefix: "Wipe" });
+            throw new Error("Bulk deletion required for wipe operations");
+        }
+        const DELETE_BATCH_SIZE = 250; // How many rows to delete per batch
         let totalDeleted = 0;
-        let cursor;
         let hasMoreRows = true;
         MessageFormatter.info("Starting optimized table row deletion...", { prefix: "Wipe" });
-        // Create progress tracker (we'll update the total as we discover more rows)
-        const progress = ProgressManager.create(`delete-${tableId}`, 1, // Start with 1, will update as we go
+        const progress = ProgressManager.create(`delete-${tableId}`, 1, // Start with 1, will update as we discover more
         { title: "Deleting table rows" });
         while (hasMoreRows) {
-            // Fetch next batch of rows
-            const queries = [Query.limit(FETCH_BATCH_SIZE)];
-            if (cursor) {
-                queries.push(Query.cursorAfter(cursor));
-            }
-            const response = await adapter.listRows({ databaseId, tableId, queries });
-            const rows = response.rows || [];
-            if (rows.length === 0) {
-                hasMoreRows = false;
-                break;
-            }
-            // Update progress total as we discover more rows
-            if (rows.length === FETCH_BATCH_SIZE) {
-                // There might be more rows, update progress total
-                progress.setTotal(totalDeleted + rows.length + 1000); // Estimate more
-            }
-            MessageFormatter.progress(`Processing batch: ${rows.length} rows (${totalDeleted + rows.length} total so far)`, { prefix: "Wipe" });
-            // Try to use bulk deletion first, fall back to individual deletion
-            const rowIds = rows.map((row) => row.$id);
-            // Check if bulk deletion is available and try it first
-            if (adapter.bulkDeleteRows) {
-                try {
-                    // Attempt bulk deletion (available in TablesDB)
-                    const deletedCount = await tryBulkDeletion(adapter, databaseId, tableId, rowIds, BULK_DELETE_BATCH_SIZE, MAX_CONCURRENT_OPERATIONS);
-                    totalDeleted += deletedCount;
-                    progress.update(totalDeleted);
-                }
-                catch (bulkError) {
-                    // Enhanced error handling: categorize the error and decide on fallback strategy
-                    const errorMessage = bulkError instanceof Error ? bulkError.message : String(bulkError);
-                    if (isRetryableError(errorMessage)) {
-                        MessageFormatter.progress(`Bulk deletion encountered retryable error, retrying with individual deletion for ${rows.length} rows`, { prefix: "Wipe" });
-                    }
-                    else if (isBulkNotSupportedError(errorMessage)) {
-                        MessageFormatter.progress(`Bulk deletion not supported by server, switching to individual deletion for ${rows.length} rows`, { prefix: "Wipe" });
-                    }
-                    else {
-                        MessageFormatter.progress(`Bulk deletion failed (${errorMessage}), falling back to individual deletion for ${rows.length} rows`, { prefix: "Wipe" });
-                    }
-                    const deletedCount = await tryIndividualDeletion(adapter, databaseId, tableId, rows, INDIVIDUAL_DELETE_BATCH_SIZE, MAX_CONCURRENT_OPERATIONS, progress, totalDeleted);
-                    totalDeleted += deletedCount;
+            try {
+                // Delete next batch using Query.limit() - no fetching needed!
+                const result = await tryAwaitWithRetry(async () => adapter.bulkDeleteRows({
+                    databaseId,
+                    tableId,
+                    rowIds: [], // Empty array signals we want to use Query.limit instead
+                    batchSize: DELETE_BATCH_SIZE
+                }));
+                const deletedCount = result.total || 0;
+                if (deletedCount === 0) {
+                    hasMoreRows = false;
+                    break;
                 }
-            }
-            else {
-                // Bulk deletion not available, use optimized individual deletion
-                MessageFormatter.progress(`Using individual deletion for ${rows.length} rows (bulk deletion not available)`, { prefix: "Wipe" });
-                const deletedCount = await tryIndividualDeletion(adapter, databaseId, tableId, rows, INDIVIDUAL_DELETE_BATCH_SIZE, MAX_CONCURRENT_OPERATIONS, progress, totalDeleted);
                 totalDeleted += deletedCount;
+                progress.setTotal(totalDeleted + 100); // Estimate more rows exist
+                progress.update(totalDeleted);
+                MessageFormatter.progress(`Deleted ${deletedCount} rows (${totalDeleted} total so far)`, { prefix: "Wipe" });
+                // Small delay between batches to be respectful to the API
+                await delay(10);
             }
-            // Set up cursor for next iteration
-            if (rows.length < FETCH_BATCH_SIZE) {
-                hasMoreRows = false;
-            }
-            else {
-                cursor = rows[rows.length - 1].$id;
+            catch (error) {
+                const errorMessage = error.message || String(error);
+                if (isCriticalError(errorMessage)) {
+                    MessageFormatter.error(`Critical error during bulk deletion: ${errorMessage}`, error, { prefix: "Wipe" });
+                    throw error;
+                }
+                else {
+                    MessageFormatter.error(`Error during deletion batch: ${errorMessage}`, error, { prefix: "Wipe" });
+                    // Continue trying with next batch
+                }
             }
-            // Small delay between fetch cycles to be respectful to the API
-            await delay(10);
         }
         // Update final progress total
         progress.setTotal(totalDeleted);
@@ -259,77 +231,3 @@ export const wipeTableRows = async (adapter, databaseId, tableId) => {
         throw error;
     }
 };
-/**
- * Helper function to attempt bulk deletion of row IDs
- */
-async function tryBulkDeletion(adapter, databaseId, tableId, rowIds, batchSize, maxConcurrent) {
-    if (!adapter.bulkDeleteRows) {
-        throw new Error("Bulk deletion not available on this adapter");
-    }
-    const limit = pLimit(maxConcurrent);
-    const batches = chunk(rowIds, batchSize);
-    let successfullyDeleted = 0;
-    const deletePromises = batches.map((batch) => limit(async () => {
-        try {
-            const result = await tryAwaitWithRetry(async () => adapter.bulkDeleteRows({ databaseId, tableId, rowIds: batch }));
-            successfullyDeleted += batch.length; // Assume success if no error thrown
-        }
-        catch (error) {
-            const errorMessage = error.message || String(error);
-            // Enhanced error handling for bulk deletion
-            if (isCriticalError(errorMessage)) {
-                MessageFormatter.error(`Critical error in bulk deletion batch: ${errorMessage}`, error, { prefix: "Wipe" });
-                throw error;
-            }
-            else {
-                // For non-critical errors in bulk deletion, re-throw to trigger fallback
-                throw new Error(`Bulk deletion batch failed: ${errorMessage}`);
-            }
-        }
-    }));
-    await Promise.all(deletePromises);
-    return successfullyDeleted;
-}
-/**
- * Helper function for fallback individual deletion
- */
-async function tryIndividualDeletion(adapter, databaseId, tableId, rows, batchSize, maxConcurrent, progress, baseDeleted) {
-    const limit = pLimit(maxConcurrent);
-    const batches = chunk(rows, batchSize);
-    let processedInBatch = 0;
-    let successfullyDeleted = 0;
-    const deletePromises = batches.map((batch) => limit(async () => {
-        const batchDeletePromises = batch.map(async (row) => {
-            try {
-                await tryAwaitWithRetry(async () => adapter.deleteRow({ databaseId, tableId, id: row.$id }));
-                successfullyDeleted++;
-            }
-            catch (error) {
-                const errorMessage = error.message || String(error);
-                // Enhanced error handling for row deletion
-                if (errorMessage.includes("Row with the requested ID could not be found")) {
-                    // Row already deleted, count as success since it's gone
-                    successfullyDeleted++;
-                }
-                else if (isCriticalError(errorMessage)) {
-                    // Critical error, log and rethrow to stop operation
-                    MessageFormatter.error(`Critical error deleting row ${row.$id}: ${errorMessage}`, error, { prefix: "Wipe" });
-                    throw error;
-                }
-                else if (isRetryableError(errorMessage)) {
-                    // Retryable error, will be handled by tryAwaitWithRetry
-                    MessageFormatter.progress(`Retryable error for row ${row.$id}, will retry`, { prefix: "Wipe" });
-                }
-                else {
-                    // Other non-critical errors, log but continue
-                    MessageFormatter.error(`Failed to delete row ${row.$id}: ${errorMessage}`, error, { prefix: "Wipe" });
-                }
-            }
-            processedInBatch++;
-            progress.update(baseDeleted + successfullyDeleted);
-        });
-        await Promise.all(batchDeletePromises);
-    }));
-    await Promise.all(deletePromises);
-    return successfullyDeleted;
-}